home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2004 #2 / Amiga Plus CD - 2004 - No. 02.iso / AmiSoft / Disk / moni / FileX-src.lha / FileX-src / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  2003-09-20  |  56.7 KB  |  2,723 lines
  1. /*
  2.  * FileX © 1993-1994 bei Klaas Hermanns
  3.  *       © 2003 Pavel Fedin
  4.  */
  5.         /* Eigene Includes */
  6.  
  7. #include "FileX.h"
  8. #include "FileXStructs.h"
  9. #include "FileXStrings.h"
  10. #include "FileXARexx.h"
  11.  
  12.     /* Prototypes */
  13.  
  14. #include "allprotos.h"
  15. #include "FileXARexx_protos.h"
  16.  
  17.     /* LibraryBases */
  18.  
  19. struct Library *CxBase;
  20. struct Library *KeymapBase;
  21. struct IntuitionBase *IntuitionBase;
  22. struct Library *GadToolsBase;
  23. struct Library *DiskfontBase;
  24. struct Library *AslBase;
  25. struct Library *RexxSysBase;
  26. struct ReqToolsBase *ReqToolsBase;
  27. struct GfxBase *GfxBase;
  28. struct IconBase *IconBase;
  29. struct Library *UtilityBase;
  30. /*struct Library *XpkBase;*/
  31. struct DosLibrary *DOSBase;
  32. struct Library *WorkbenchBase;
  33. struct Library *IFFParseBase;
  34. struct ExecBase *SysBase;
  35. struct LocaleBase *LocaleBase;
  36.  
  37. char programname[256];
  38. extern void __saveds DoWindow(void);    /* Prototype für Hauptschleifenfkt. */
  39. static char errorbuffer[256];
  40.  
  41. struct MsgPort *WndPort;    /* Port für alle IDCMP-Nachrichten */
  42. struct MsgPort *AppPort;    /* AppPort für alle Windows */
  43.  
  44. static WORD MoveStatusBalkenY, MoveStatusBalkenMaxOff, MoveStatusBalkenMinOff;
  45.  
  46. struct DisplayData *AktuDD;
  47. struct DisplayInhalt *AktuDI;
  48.  
  49. static struct List OldFileList = {
  50.     ( struct Node * )&OldFileList.lh_Tail,
  51.     0,
  52.     ( struct Node * )&OldFileList.lh_Head,
  53.     0,0
  54. };
  55. struct List FileList = {
  56.     ( struct Node * )&FileList.lh_Tail,
  57.     0,
  58.     ( struct Node * )&FileList.lh_Head,
  59.     0,0
  60. };
  61. struct List DisplayInhaltList = {
  62.     ( struct Node * )&DisplayInhaltList.lh_Tail,
  63.     0,
  64.     ( struct Node * )&DisplayInhaltList.lh_Head,
  65.     0,0
  66. };
  67.  
  68. /*void Gibs( void )
  69. {
  70.     struct FileData *FD;
  71.     struct DisplayData *DD;
  72.     struct DisplayInhalt *DI;
  73.  
  74.     FD = (struct FileData *)FileList.lh_Head;
  75.  
  76.     while( FD != ( struct FileData * )&FileList.lh_Tail )
  77.     {
  78.         Printf("FileData = %8lx >%s<\n", FD, FD->Name );
  79.  
  80.         DD = (struct DisplayData *)FD->DisplayList.lh_Head;
  81.  
  82.         while( DD != ( struct DisplayData * )&FD->DisplayList.lh_Tail )
  83.         {
  84.             Printf("        %8lx %8lx %8lx\n", DD, DD->FD, DD->DI );
  85.             DD = ( struct DisplayData *)DD->Node.ln_Succ;
  86.         }
  87.  
  88.         FD = ( struct FileData *)FD->Node.ln_Succ;
  89.     }
  90.  
  91.     DI = (struct DisplayInhalt *)DisplayInhaltList.lh_Head;
  92.  
  93.     while( DI != ( struct DisplayInhalt * )&DisplayInhaltList.lh_Tail )
  94.     {
  95.         Printf("DisplayInhalt = %8lx\n", DI );
  96.  
  97.         DD = (struct DisplayData *)DI->DisplayList.lh_Head;
  98.  
  99.         while( DD != ( struct DisplayData * )&DI->DisplayList.lh_Tail )
  100.         {
  101.             Printf("        %8lx %8lx %8lx\n", DD, DD->FD, DD->DI );
  102.             DD = ( struct DisplayData *)DD->Node.ln_Succ;
  103.         }
  104.  
  105.         DI = ( struct DisplayInhalt *)DI->Node.ln_Succ;
  106.     }
  107. }
  108. */
  109. #define SECRETNUMBER 4
  110. int secretpos = -1;
  111. char *secret[] = 
  112. {
  113. "You have activated the secret mode!",
  114. /*"SWF3 C-Team mit Krisi und Anke!",*/
  115. /*"SUPERTRAMP ist genial!!",*/
  116. /*"M * A * S * H!",*/
  117. /*"Save the Whales!",*/
  118. /*"Rottach '91-'93!",*/
  119. /*"Zweifel Chips, kalte Schnitzel, Schlappen Baguette.",*/
  120. /*"Jack and Jill went up the hill!",*/
  121. "Fish don't like milk!",
  122. "We do not burn, we shine!",
  123. "Dreadlock holiday!",
  124. "Even the trees had been a bad move...",
  125. };
  126.  
  127. long ElementZahl( struct List *l )
  128. {
  129.     struct Node *n;
  130.     long a = 0;
  131.  
  132.     n = l->lh_Head;
  133.  
  134.     while( n != ( struct Node * )&l->lh_Tail )
  135.     {
  136.         a++;
  137.  
  138.         n = n->ln_Succ;
  139.     }
  140.  
  141.     return( a );
  142. }
  143.  
  144. /*
  145.  * ChecksumCorrect()
  146.  *
  147.  * Prüft die Checksumme eines Keys.
  148.  * -1 => Kein Key vorhanden.
  149.  * 1 => Checksumme ok.
  150.  * 0 => Checksumme falsch!
  151.  */
  152. /* Removed by Pavel Fedin
  153. static long ChecksumCorrect( void )
  154. {
  155.     ULONG realchecksumme = 0xdead;
  156.     int k;
  157.  
  158.     if( regname[0] == 0 ) return( -1 );
  159.  
  160.     for(k = 0; k < strlen(regname); k++)
  161.     {
  162.         realchecksumme += regname[ k ] << 4;
  163.         realchecksumme ^= regname[ k ] << 24;
  164.     }
  165.  
  166.     realchecksumme ^= regnum;
  167.  
  168.     if( realchecksumme == checksumme )
  169.         return( 1 );
  170.     else
  171.         return( 0 );
  172. }
  173.  
  174. static BOOL LoadKeyFile( char *KeyFileName )
  175. {
  176.     BPTR fh;
  177.     BOOL Success = FALSE;
  178.  
  179.     if( fh = Open( KeyFileName, MODE_OLDFILE ))
  180.     {
  181.         static UBYTE Key[256];
  182.         LONG KeyLaenge, namelaenge, k;
  183.         UBYTE *ptr;
  184.  
  185.         KeyLaenge = Read( fh, Key, 256 );
  186.  
  187.         ptr = Key + 4;
  188.  
  189.         for( k = 0; *ptr != 0xa5; k++ )
  190.         {
  191.             regname[ k ] = *ptr ^ 0xa5;
  192.             ptr += 3;
  193.         }
  194.  
  195.         regname[ namelaenge = k ] = 0;
  196.  
  197.         regnum = 0;
  198.         regnum += Key[ KeyLaenge - 8 ] << 24;
  199.         regnum += Key[ KeyLaenge - 6 ] << 16;
  200.         regnum += Key[ KeyLaenge - 3 ] << 8;
  201.         regnum += Key[ KeyLaenge - 1 ];
  202.         regnum ^= 0x11223344;
  203.  
  204.         checksumme = 0;
  205.         checksumme += Key[ KeyLaenge - 7 ] << 16;
  206.         checksumme += Key[ KeyLaenge - 5 ] << 24;
  207.         checksumme += Key[ KeyLaenge - 4 ] << 8;
  208.         checksumme += Key[ KeyLaenge - 2 ];
  209.  
  210.         Close( fh );
  211.  
  212.         Success = TRUE;
  213.     }
  214.  
  215.     return( Success );
  216. }*/
  217.  
  218. BOOL QuitView( long Typ, struct DisplayData *DD )
  219. {
  220.     long z;
  221.  
  222.         /* Falls wir im Grabmemorymodus sind, keine Sicherheitsabfrage */
  223.  
  224.     if( DD->FD->Typ == FD_GRAB )
  225.         return( TRUE );
  226.  
  227.     z = ElementZahl( &DD->FD->DisplayList );
  228.  
  229.     if(( z != 1) || (( z == 1 ) && ( QuitRequester( Typ, DD ))))
  230.         return( TRUE );
  231.     else
  232.         return( FALSE );
  233. }
  234.  
  235. BOOL QuitRequester( long Typ, APTR Zeiger )
  236. {
  237.     struct FileData *FD, *OneFD = NULL;
  238.     struct DisplayInhalt *DI;
  239.     struct DisplayData *DD;
  240.     long Changes = 0;
  241.     long Anzahl = 0;
  242.  
  243.     switch( Typ )
  244.     {
  245.         case 0:
  246.             FD = (struct FileData *)FileList.lh_Head;
  247.  
  248.             while( FD != ( struct FileData * )&FileList.lh_Tail )
  249.             {
  250.                 if( FD->Typ == FD_FILE )
  251.                 {
  252.                     Changes += FD->FullChanges + FD->Changes + FD->RedoChanges;
  253.         
  254.                     if( Changes ) Anzahl++;
  255.         
  256.                     OneFD = FD;
  257.                 }
  258.         
  259.                 FD = ( struct FileData *)FD->Node.ln_Succ;
  260.             }
  261.             break;
  262.  
  263.         case 1:
  264.             DI = ( struct DisplayInhalt * )Zeiger;
  265.             FD = (struct FileData *)FileList.lh_Head;
  266.  
  267.             while( FD != ( struct FileData * )&FileList.lh_Tail )
  268.             {
  269.                 struct DisplayData *DD;
  270.                 BOOL Found = FALSE;
  271.  
  272.                 DD = GetDDFromFD( FD->DisplayList.lh_Head );
  273.  
  274.                 while( DD != GetDDFromFD( &FD->DisplayList.lh_Tail ))
  275.                 {
  276.                     if( DD->DI == DI )
  277.                     {
  278.                         Found = TRUE;
  279.                         break;
  280.                     }
  281.                     DD = GetDDFromFD( DD->FNode.ln_Succ );
  282.                 }
  283.  
  284.                 if( Found && ( FD->Typ == FD_FILE ))
  285.                 {
  286.                     Changes += FD->FullChanges + FD->Changes + FD->RedoChanges;
  287.         
  288.                     if( Changes ) Anzahl++;
  289.         
  290.                     OneFD = FD;
  291.                 }
  292.         
  293.                 FD = ( struct FileData *)FD->Node.ln_Succ;
  294.             }
  295.             break;
  296.  
  297.         case 2:
  298.         case 3:
  299.         case 4:
  300.         case 5:
  301.             DD = ( struct DisplayData * )Zeiger;
  302.  
  303.             Anzahl = 1;
  304.             Changes = DD->FD->FullChanges + DD->FD->Changes + DD->FD->RedoChanges;
  305.             OneFD = DD->FD;
  306.             break;
  307.     }
  308.  
  309.     if( Changes )
  310.     {
  311.         char ReqText[256];
  312.  
  313.         if( Anzahl == 1 )
  314.             strcpy( ReqText, GetStr( MSG_INFO_GLOBAL_CHANGESTOFILE ));
  315.         else
  316.             strcpy( ReqText, GetStr( MSG_INFO_GLOBAL_CHANGESTOFILES ));
  317.                 
  318.         switch( Typ )
  319.         {
  320.             case 0:
  321.                 strcat( ReqText, GetStr( MSG_INFO_GLOBAL_WANTTOQUIT ));
  322.                 break;
  323.             case 1:
  324.                 strcat( ReqText, GetStr( MSG_INFO_GLOBAL_WANTTOCLOSEWINDOW ));
  325.                 break;
  326.             case 2:
  327.                 strcat( ReqText, GetStr( MSG_INFO_GLOBAL_WANTTOCLOSEVIEW ));
  328.                 break;
  329.             case 3:
  330.                 strcat( ReqText, GetStr( MSG_INFO_GLOBAL_WANTTOCLEAR ));
  331.                 break;
  332.             case 4:
  333.                 strcat( ReqText, GetStr( MSG_INFO_GLOBAL_WANTTOGRAB ));
  334.                 break;
  335.             case 5:
  336.                 strcat( ReqText, GetStr( MSG_INFO_GLOBAL_WANTTOOPEN ));
  337.                 break;
  338.         }
  339.  
  340.         if( Anzahl == 1 )
  341.             return(( BOOL )MyFullRequestNoLocale( ReqText, GetStr( MSG_GADGET_CHANGES ), Changes, (*FilePart( OneFD->Name )) ? (OneFD->Name) : ((UBYTE *)GetStr( MSG_INFO_GLOBAL_UNNAMED ))));
  342.         else
  343.             return(( BOOL )MyFullRequestNoLocale( ReqText, GetStr( MSG_GADGET_CHANGES ), Changes, Anzahl ));
  344.     }
  345.     else
  346.         return( TRUE );
  347. }
  348.  
  349. static void __saveds OldFileListCallBack( struct List *List, struct Node *node )
  350. {
  351.     if( node )
  352.         MyOpen( node->ln_Name, AktuDD );
  353. }
  354.  
  355. static BOOL DoMenu( struct IntuiMessage *Msg )
  356. {
  357.     UWORD Number;
  358.     BOOL Stop = FALSE;
  359.  
  360.     Number = Msg->Code;
  361.  
  362.     while(( !Stop ) && ( Number != MENUNULL ))
  363.     {
  364.         struct MenuItem *mi;
  365.         
  366.         if(mi = ItemAddress(FileXMenus, Number))
  367.         {
  368.             switch(MENUNUM(Number))
  369.             {
  370.                 case 0:                    /* Project */
  371.                     switch(ITEMNUM(Number))
  372.                     {
  373.                         case    0:            /* New */
  374.                             ClearDDFile( AktuDD, FALSE );
  375.                             break;
  376.                         case    1:            /* Open */
  377.                             if( QuitView( 5, AktuDD ))
  378.                                 OpenFile( AktuDD );
  379.                             break;
  380.                         case    2:            /* Open previous */
  381.                             if( !IsListEmpty( &OldFileList ))
  382.                             {
  383.                                 if( QuitView( 5, AktuDD ))
  384.                                     OpenListReq( &OldFileList, GetStr( MSG_WINDOWTITLE_PREVIOUSFILES ), &OldFileListCallBack );
  385.                             }
  386.                             else
  387.                                 MyBeep();
  388.                             break;
  389.                         case    4:            /* Save */
  390.                             SaveFile( AktuDD->FD );
  391.                             break;
  392.                         case    5:            /* Save as */
  393.                             SaveAsFile( AktuDD->FD );
  394.                             break;
  395.                         case    7:            /* View */
  396.                             switch(SUBNUM(Number))
  397.                             {
  398.                                 case    0:
  399.                                     NewDisplay( FALSE );
  400.                                     break;
  401.                                 case    1:
  402.                                     NewDisplay( TRUE );
  403.                                     break;
  404.                                 case    3:
  405.                                     ActivateNextDisplay();
  406.                                     break;
  407.                                 case    4:
  408.                                     ActivatePreviousDisplay();
  409.                                     break;
  410.                                 case    6:
  411.                                     MakeDisplayMax( AktuDD );
  412.                                     break;
  413.                                 case    8:
  414.                                     MakeDisplayBigger( AktuDD );
  415.                                     break;
  416.                                 case    9:
  417.                                     MakeDisplaySmaller( AktuDD );
  418.                                     break;
  419.                                 case    11:
  420.                                     if( SaveFile( AktuDD->FD ))
  421.                                         Stop = CloseAktuView();
  422.                                     break;
  423.                                 case    12:
  424.                                     Stop = CloseAktuView();
  425.                                     break;
  426.                             }
  427.                             break;
  428.                         case    8:            /* Window */
  429.                             switch(SUBNUM(Number))
  430.                             {
  431.                                 case    0:
  432.                                     OpenNewWindow( FALSE );
  433.                                     break;
  434.                                 case    1:
  435.                                     OpenNewWindow( TRUE );
  436.                                     break;
  437.                                 case    3:
  438.                                     ActivateNextWindow();
  439.                                     break;
  440.                                 case    4:
  441.                                     ActivatePreviousWindow();
  442.                                     break;
  443.                                 case    6:
  444.                                     Stop = CloseAktuWindow();
  445.                                     break;
  446.                             }
  447.                             break;
  448.                         case    10:
  449.                             if(QuitView( 4, AktuDD ))
  450.                                 OpenGrabWindow();
  451.                             break;
  452.                         case    12:            /* Print */
  453.                             PrintFile( AktuDD->FD );
  454.                             break;
  455.                         case    14:        /* Iconify */
  456.                             mainflags |= MF_ICONIFY;
  457.                             break;
  458.                         case    16:        /* About */
  459.                             About();
  460.                             break;
  461.                         case    18:        /* Quit */
  462.                             if( QuitRequester( 0, 0 ))
  463.                                 mainflags |= MF_ENDE;
  464.                             break;
  465.                     }
  466.                     break;
  467.                 case 1:                    /* Edit */
  468.                     switch(ITEMNUM(Number))
  469.                     {
  470.                         case    0:            /* Mark Block */
  471.                             Mark( AktuDD );
  472.                             break;
  473.                         case    2:            /* Cut Block */
  474.                             Cut(AktuDD);
  475.                             break;
  476.                         case    3:            /* Copy Block */
  477.                             Copy(AktuDD);
  478.                             break;
  479.                         case    4:            /* Fill */
  480.                             if(AktuDD->Flags&DD_MARK)
  481.                                 OpenFillWindow();
  482.                             else
  483.                                 DisplayLocaleText( MSG_INFO_GLOBAL_NOBLOCKMARKED );
  484.                             break;
  485.                         case    6:            /* Paste */
  486.                             Paste(AktuDD);
  487.                             break;
  488.                         case    7:            /* Insert */
  489.                             if( !( AktuDD->FD->Typ == FD_GRAB ))
  490.                                 InsertBlock(AktuDD);
  491.                             else
  492.                                 DisplayLocaleText( MSG_INFO_GLOBAL_INSERTINGNOTPOSSIBLEINGRABMODE );
  493.                             break;
  494.                         case    8:
  495.                             if( !( AktuDD->FD->Typ == FD_GRAB ))
  496.                                 AppendBlock(AktuDD);
  497.                             else
  498.                                 DisplayLocaleText( MSG_INFO_GLOBAL_APPENDINGNOTPOSSIBLEINGRABMODE );
  499.                             break;
  500.                         case    9:        /* Print Block */
  501.                             PrintBlock();
  502.                             break;
  503.                         case    11:
  504.                             LoadBlockFR();
  505.                             break;
  506.                         case    12:
  507.                             SaveBlockFR();
  508.                             break;
  509.                         case    14:
  510.                             if( !Undo( AktuDD->FD ))
  511.                                 DisplayLocaleText( MSG_INFO_GLOBAL_NOTHINGTOUNDO );
  512.                             break;
  513.                         case    15:
  514.                             if( !Redo( AktuDD->FD ))
  515.                                 DisplayLocaleText( MSG_INFO_GLOBAL_NOTHINGTOREDO );
  516.                             break;
  517.                         case    17:
  518.                             if(( AktuDD->DisplayForm & DF_HEXASCII ) == DF_HEXASCII )
  519.                                 WechselCursorBereich( AktuDD );
  520.                             break;
  521.                     }
  522.                     break;
  523.                 case 2:                    /* Search and Replace */
  524.                     switch(ITEMNUM(Number))
  525.                     {
  526.                         case    0:
  527.                             OpenSearchWindow( FALSE );
  528.                             break;
  529.                         case    1:
  530.                             OpenSearchWindow( TRUE );
  531.                             break;
  532.                         case    2:
  533.                             SearchNext(0,FALSE,FALSE,AktuDD);
  534.                             break;
  535.                         case    3:
  536.                             SearchNext(BM_BACKWARD,FALSE,FALSE,AktuDD);
  537.                             break;
  538.                     }
  539.                     break;
  540.                 case 3:            /* Settings */
  541.                     switch(ITEMNUM(Number))
  542.                     {
  543.                         case    0:
  544.                             AdjustWindowSize( AktuDI );
  545.                             break;
  546.  
  547.                         case    2:            /* Display */
  548.                             switch(SUBNUM(Number))
  549.                             {
  550.                                 case    1:            /* only ASCII */
  551.                                     SetDisplayTyp( 0, AktuDD );
  552.                                     break;
  553.                                 case    0:            /* nur Buchtsaben und Zahlen */
  554.                                     SetDisplayTyp( 1, AktuDD );
  555.                                     break;
  556.                                 case    2:            /* all */
  557.                                     SetDisplayTyp( 2, AktuDD );
  558.                                     break;
  559.                                 case    4:            /* Userdefined */
  560.                                     SetDisplayTyp( 3, AktuDD );
  561.                                     break;
  562.                                 case    5:
  563.                                     LoadUserDisplaytypFR();
  564.                                     break;
  565.                             }
  566.                             break;
  567.                         case    4:            /* Select Font... */
  568.                             DoFontrequester( AktuDI );
  569.                             break;
  570.                         case    5:            /* Screen */
  571.                             Stop = TRUE;
  572.  
  573.                             switch(SUBNUM(Number))
  574.                             {
  575.                                 case    1:            /* Workbench */
  576.                                     ReopenDisplay(SF_WORKBENCH);
  577.                                     break;
  578.                                 case    2:            /* Public */
  579.                                     OpenPubScreenListReq();
  580.                                     break;
  581.                                 case    3:            /* Own Public */
  582.                                     SetScreenOwnPublic();
  583.                                     break;
  584.                                 case    0:            /* Default Public */
  585.                                     ReopenDisplay(SF_DEFAULT_PUBLIC);
  586.                                     break;
  587.                             }
  588.                             break;
  589.                         case    6:            /* Palette... */
  590.                             Palette();
  591.                             break;
  592.                         case    8:            /* Miscellaneous... */
  593.                             OpenMiscSettings();
  594.                             break;
  595.                         case    10:            /* Load Settings... */
  596.                             LoadSettingsFR();
  597.                             Stop = TRUE;
  598.                             break;
  599.                         case    11:            /* Save Settings */
  600.                             SaveSettingsDefault();
  601.                             break;
  602.                         case    12:            /* Save Settings as...*/
  603.                             SaveSettingsFR();
  604.                             break;
  605.                     }
  606.                     break;
  607.                 case 4:                    /* Move */
  608.                     switch(ITEMNUM(Number))
  609.                     {
  610.                         case 0:
  611.                             if( AktuDD->FD->Len ) JumpToByte();
  612.                             else MyBeep();
  613.                             break;
  614.                         case 2:
  615.                             MarkLocation( 0, AktuDD );
  616.                             break;
  617.                         case 3:
  618.                             JumpToLocation( 0, AktuDD );
  619.                             break;
  620.                     }
  621.                     break;
  622.                 case 5:                    /* ARexx */
  623.                     switch(ITEMNUM(Number))
  624.                     {
  625.                         case 0:
  626. /*                            OpenCommandShell();*/
  627.                             break;
  628.                         case 2:
  629.                             ExecuteARexxCommand(0);
  630.                             break;
  631.                         case 3:
  632.                             SetARexxCommand(-1,0);
  633.                             Stop = TRUE;
  634.                             break;
  635.                         case 16:
  636.                             if( LoadARexxCommandsFR())
  637.                                 Stop = TRUE;
  638.                             break;
  639.                         case 17:
  640.                             SaveARexxCommandsDefault();
  641.                             break;
  642.                         case 18:
  643.                             SaveARexxCommandsFR();
  644.                             break;
  645.                         default:
  646.                             if((ITEMNUM(Number)>=5)&&(ITEMNUM(Number)<=15))
  647.                             {
  648.                                 ExecuteARexxCommandNumber(ITEMNUM(Number)-5);
  649.                             }
  650.                             break;
  651.                     }
  652.                     break;
  653.  
  654.                 case 6:                    /* Misc */
  655.                     switch(ITEMNUM(Number))
  656.                     {
  657.                         case 0:
  658.                             OpenCalc();
  659.                             break;
  660.                         case 1:
  661.                             OpenClipConv();
  662.                             break;
  663.                     }
  664.                     break;
  665.             }
  666.             Number = mi->NextSelect;
  667.         }
  668.         else
  669.             break;
  670.     }
  671.  
  672.     return( Stop );
  673. }
  674.  
  675. void DoFileXWindowMessage( void )
  676. {
  677.     struct IntuiMessage *m, Msg;
  678. /*    BOOL Stop = FALSE;*/
  679.     struct DisplayInhalt *DI;
  680.  
  681.     while(m = ( struct IntuiMessage * )GetMsg( WndPort ))
  682.     {
  683.         DI = ( struct DisplayInhalt * )m->IDCMPWindow->UserData;
  684.  
  685. /*    while(( !Stop ) && ( !( mainflags & MF_ENDE )) && DI->Wnd && (m = ( struct IntuiMessage * )GetMsg( DI->Wnd->UserPort )))*/
  686.         CopyMem((char *)m, (char *)&Msg, (long)sizeof(struct IntuiMessage));
  687.  
  688.         ReplyMsg(( struct Message * )m );
  689.  
  690. /*        PrintIntuiMessage( &Msg );*/
  691.  
  692.         switch( Msg.Class )
  693.         {
  694.             case IDCMP_ACTIVEWINDOW:
  695.                 MyActivateWindow( DI );
  696.                 break;
  697.  
  698.             case    IDCMP_VANILLAKEY:
  699.                 switch( Msg.Code )
  700.                 {
  701.                     case 27:
  702.                         /*Stop = */CloseAktuWindow();
  703.                         break;
  704.                     default:
  705.                         if( AktuDD->FD->Len )
  706.                         {
  707.                             if( AktuDD->Flags & DD_HEX )
  708.                             {
  709.                                 if(isxdigit(Msg.Code))
  710.                                 {
  711.                                     UBYTE oldwert=AktuDD->FD->Mem[AktuDD->CPos];
  712.     
  713.                                     if(!(AktuDD->Flags&DD_HEXEDITPOS))
  714.                                     {
  715.     
  716.                                         AktuDD->FD->Mem[AktuDD->CPos]&=0xf;
  717.                                         if(isdigit(Msg.Code))
  718.                                             AktuDD->FD->Mem[AktuDD->CPos]+=(Msg.Code-'0') * 0x10;
  719.                                         else
  720.                                             AktuDD->FD->Mem[AktuDD->CPos]+=(tolower(Msg.Code)-'a'+10)*0x10;
  721.     
  722.                                         AddUndoCharHex(AktuDD->CPos,oldwert,AktuDD->FD->Mem[AktuDD->CPos],FALSE, AktuDD->FD );
  723.     
  724.                                         AllDisplayChar( AktuDD->FD, AktuDD->CPos );
  725.                                         UpdateAllStatusZeilen( AktuDD->FD );
  726.                                         AktuDD->Flags|=DD_HEXEDITPOS;
  727.                                     }
  728.                                     else
  729.                                     {
  730.                                         AktuDD->FD->Mem[AktuDD->CPos]&=0xf0;
  731.                                         if(isdigit(Msg.Code))
  732.                                             AktuDD->FD->Mem[AktuDD->CPos]+=(Msg.Code-'0');
  733.                                         else
  734.                                             AktuDD->FD->Mem[AktuDD->CPos]+=tolower(Msg.Code)-'a'+10;
  735.     
  736.                                         AddUndoCharHex(AktuDD->CPos,oldwert,AktuDD->FD->Mem[AktuDD->CPos],TRUE, AktuDD->FD );
  737.     
  738.                                         AllDisplayChar( AktuDD->FD, AktuDD->CPos );
  739.                                         UpdateAllStatusZeilen( AktuDD->FD );
  740.                                         MoveCursorX( 1, AktuDD );
  741.                                         AktuDD->Flags&=~DD_HEXEDITPOS;
  742.                                     }
  743.                                 }
  744.                                 else
  745.                                     MyBeep();
  746.                             }
  747.                             else
  748.                             {
  749.                                 AddUndoChar(AktuDD->CPos,AktuDD->FD->Mem[AktuDD->CPos],Msg.Code, AktuDD->FD );
  750.                                 AktuDD->FD->Mem[AktuDD->CPos]=Msg.Code;
  751.                                 AllDisplayChar( AktuDD->FD, AktuDD->CPos );
  752.                                 UpdateAllStatusZeilen( AktuDD->FD );
  753.                                 MoveCursorX( 1, AktuDD );
  754.                             }
  755.                         }
  756.                         else
  757.                             MyBeep();
  758.                         break;
  759.                 }
  760.                 break;
  761.  
  762.             case IDCMP_RAWKEY:
  763.                             /* Mögliche Qualifier:    0x08=CONTROL */
  764.                             /*                             0x01=LSHIFT     */
  765.                             /*                             0x02=RSHIFT     */
  766.                             /*                             0x10=LALT     */
  767.                             /*                             0x20=RALT     */
  768.                             /*                             0x40=LAMIGA  */
  769.                             /*                             0x80=RAMIGA  */
  770.                 if((Msg.Qualifier & 0x02) && (Msg.Qualifier & 0x08))    /* RShift Ctrl */
  771.                 switch(Msg.Code)
  772.                 {
  773.                     case CURSORDOWN:
  774.                         if( secretpos == -1 )
  775.                             secretpos = 0;
  776.                         else
  777.                         {
  778.                             secretpos++;
  779.                             if( secretpos >= SECRETNUMBER ) secretpos = 0;
  780.                         }
  781.                         SetStatusZeile( secret[ secretpos ], AktuDD );
  782.                         break;
  783.                     case CURSORUP:
  784.                         if( secretpos == -1 )
  785.                             secretpos = 0;
  786.                         else
  787.                         {
  788.                             secretpos--;
  789.                             if( secretpos < 0 ) secretpos = SECRETNUMBER - 1;
  790.                         }
  791.                         SetStatusZeile( secret[ secretpos ], AktuDD );
  792.                         break;
  793.                 }
  794.                 if(Msg.Qualifier & (0x10|0x20))    /* Alts */
  795.                 switch(Msg.Code)
  796.                 {
  797.                     case CURSORDOWN:
  798.                         MoveCursorY( altsprungweite, AktuDD );
  799.                         break;
  800.                     case CURSORUP:
  801.                         MoveCursorY( -altsprungweite, AktuDD );
  802.                         break;
  803.                     case CURSORRIGHT:
  804.                         SetCursorAltRight( AktuDD );
  805.                         break;
  806.                     case CURSORLEFT:
  807.                         SetCursorAltLeft( AktuDD );
  808.                         break;
  809.                 }
  810.                 else
  811.                 if(Msg.Qualifier & (0x01|0x02))    /* Shifts */
  812.                 switch(Msg.Code)
  813.                 {
  814.                     case CURSORDOWN:
  815.                         MoveCursorY( AktuDD->Zeilen - 1, AktuDD );
  816.                         break;
  817.                     case CURSORUP:
  818.                         MoveCursorY( 1 - AktuDD->Zeilen, AktuDD );
  819.                         break;
  820.                     case CURSORRIGHT:
  821.                         SetCursorEndOfLine( AktuDD );
  822.                         break;
  823.                     case CURSORLEFT:
  824.                         SetCursorStartOfLine( AktuDD );
  825.                         break;
  826.                 }
  827.                 else
  828.                 if(Msg.Qualifier & 0x08)                /* Control */
  829.                 switch(Msg.Code)
  830.                 {
  831.                     case CURSORUP:
  832.                         SetCursorStart( AktuDD );
  833.                         break;
  834.                     case CURSORDOWN:
  835.                         SetCursorEnd( AktuDD );
  836.                         break;
  837.                     case CURSORRIGHT:
  838.                         SetCursorEndOfLine( AktuDD );
  839.                         break;
  840.                     case CURSORLEFT:
  841.                         SetCursorStartOfLine( AktuDD );
  842.                         break;
  843.                 }
  844.                 else
  845.                 switch(Msg.Code)                        /* Nichts */
  846.                 {
  847.                     case CURSORDOWN:
  848.                         MoveCursorY( 1, AktuDD );
  849.                         break;
  850.                     case CURSORUP:
  851.                         MoveCursorY( -1, AktuDD );
  852.                         break;
  853.                     case CURSORLEFT:
  854.                         MoveCursorX( -1, AktuDD );
  855.                         break;
  856.                     case CURSORRIGHT:
  857.                         MoveCursorX( 1, AktuDD );
  858.                         break;
  859.                 }
  860.                 break;
  861.  
  862.             case    IDCMP_NEWSIZE:
  863.                 MakeDisplay( DI );
  864.                 RefreshWindowFrame( DI->Wnd );
  865.                 break;
  866.  
  867.             case    IDCMP_CLOSEWINDOW:
  868.                 /*Stop = */CloseAktuWindow();
  869.                 break;
  870.  
  871.             case    IDCMP_GADGETUP:
  872. #ifdef DEBUG
  873.                 PutStr("IDCMP_GADGETUP\n");
  874. #endif
  875.                 DisplayFromScroller( AktuDD );
  876.                 SetCursor( AktuDD->CPos, AktuDD );
  877.                 break;
  878.  
  879.             case    IDCMP_GADGETDOWN:
  880.                 if(( struct DisplayData * )(( struct Gadget * )Msg.IAddress)->UserData != AktuDD )
  881.                     ChangeAktuView(( struct DisplayData * )(( struct Gadget * )Msg.IAddress)->UserData);
  882.                 break;
  883.  
  884.             case    IDCMP_IDCMPUPDATE:
  885. #ifdef DEBUG
  886.                 PutStr("IDCMP_UPDATE\n");
  887. #endif
  888.                 DisplayFromScroller( AktuDD );
  889.                 SetCursor(AktuDD->CPos,AktuDD);
  890.                 break;
  891.  
  892.             case    IDCMP_MOUSEMOVE:
  893.                 if( mainflags & MF_MOVESTATUSBALKEN )
  894.                 {
  895.                     WORD Off;
  896.                     
  897.                     Off = Msg.MouseY - ( AktuDD->sbby - BOXADDY / 2 );
  898.  
  899.                     if( Off > 0 )
  900.                         Off = Off / DI->fhöhe;
  901.                     else
  902.                         Off = Off / DI->fhöhe - 1;
  903.  
  904.                     if(( Off >= MoveStatusBalkenMinOff ) && ( Off <= MoveStatusBalkenMaxOff ))
  905.                         if( Off != MoveStatusBalkenY )
  906.                         {
  907.                             InvertStatusBalkenRahmen( AktuDD, MoveStatusBalkenY );
  908.                             InvertStatusBalkenRahmen( AktuDD, MoveStatusBalkenY = Off );
  909.                         }
  910.                 }
  911.                 else if(mainflags&MF_MOVECURSOR)
  912.                 {
  913.                     SetzeCursorMaus(Msg.MouseX,Msg.MouseY, AktuDD,DI);
  914.                 }
  915.                 break;
  916.  
  917.             case    IDCMP_MOUSEBUTTONS:
  918.                 switch(Msg.Code)
  919.                 {
  920.                     case SELECTUP:
  921.                         AktuDI->Wnd->Flags &= ~WFLG_REPORTMOUSE;
  922.                         mainflags &= ~MF_LEFTMOUSEDOWN;
  923.                         mainflags &= ~MF_MOVECURSOR;
  924.  
  925.                         if( mainflags & MF_MOVESTATUSBALKEN )
  926.                         {
  927.                             InvertStatusBalkenRahmen( AktuDD, MoveStatusBalkenY );
  928.                             mainflags &= ~MF_MOVESTATUSBALKEN;
  929.                             ModifyIDCMP( AktuDI->Wnd, AktuDI->Wnd->IDCMPFlags | ( IDCMP_RAWKEY | IDCMP_VANILLAKEY ));
  930.  
  931.                             if( MoveStatusBalkenY != 0 )
  932.                             {
  933.                                 struct DisplayData *DD;
  934.  
  935.                                 if( MoveStatusBalkenY > 0 )
  936.                                 {
  937.                                     ((struct DisplayData *)AktuDD->Node.ln_Pred)->Zeilen += MoveStatusBalkenY;
  938.  
  939.                                     DD = AktuDD;
  940.                                     while( MoveStatusBalkenY )
  941.                                     {
  942.                                         if( DD->Zeilen - 1 > MoveStatusBalkenY )
  943.                                         {
  944.                                             DD->Zeilen -= MoveStatusBalkenY;
  945.                                             MoveStatusBalkenY = 0;
  946.                                         }
  947.                                         else
  948.                                         {
  949.                                             MoveStatusBalkenY -= DD->Zeilen -1;
  950.                                             DD->Zeilen = 1;
  951.                                         }
  952.  
  953.                                         DD = ( struct DisplayData * )DD->Node.ln_Succ;
  954.                                     }
  955.                                 }
  956.                                 else
  957.                                 {
  958.                                     MoveStatusBalkenY = -MoveStatusBalkenY;
  959.  
  960.                                     AktuDD->Zeilen += MoveStatusBalkenY;
  961.  
  962.                                     DD = ( struct DisplayData * )AktuDD->Node.ln_Pred;
  963.                                     while( MoveStatusBalkenY )
  964.                                     {
  965.                                         if( DD->Zeilen - 1 > MoveStatusBalkenY )
  966.                                         {
  967.                                             DD->Zeilen -= MoveStatusBalkenY;
  968.                                             MoveStatusBalkenY = 0;
  969.                                         }
  970.                                         else
  971.                                         {
  972.                                             MoveStatusBalkenY -= DD->Zeilen -1;
  973.                                             DD->Zeilen = 1;
  974.                                         }
  975.  
  976.                                         DD = ( struct DisplayData * )DD->Node.ln_Pred;
  977.                                     }
  978.                                 }
  979.  
  980.                                 MakeDisplay( AktuDI );
  981.                             }
  982.                         }
  983.                         break;
  984.  
  985.                     case SELECTDOWN:
  986.                         AktuDI->Wnd->Flags |= WFLG_REPORTMOUSE;
  987.                         if( StatusBalkenHit(Msg.MouseX,Msg.MouseY,AktuDI))
  988.                         {
  989.                             if( AktuDD != ( struct DisplayData *)AktuDI->DisplayList.lh_Head )
  990.                             {
  991.                                 MoveStatusBalkenY = Msg.MouseY - ( AktuDD->sbby - BOXADDY / 2 );
  992.  
  993.                                 if( MoveStatusBalkenY > 0 )
  994.                                     MoveStatusBalkenY = MoveStatusBalkenY / AktuDI->fhöhe;
  995.                                 else
  996.                                     MoveStatusBalkenY = MoveStatusBalkenY / AktuDI->fhöhe - 1;
  997.  
  998.                                 mainflags |= MF_MOVESTATUSBALKEN;
  999.  
  1000.                                 ModifyIDCMP( AktuDI->Wnd, AktuDI->Wnd->IDCMPFlags & ~( IDCMP_RAWKEY | IDCMP_VANILLAKEY ));
  1001.  
  1002.                                 {
  1003.                                     struct DisplayData *DD;
  1004.  
  1005.                                     DD = ( struct DisplayData * )AktuDD->Node.ln_Pred;
  1006.                                     MoveStatusBalkenMinOff = 0;
  1007.  
  1008.                                     while(DD != ( struct DisplayData *)&AktuDI->DisplayList.lh_Head )
  1009.                                     {
  1010.                                         MoveStatusBalkenMinOff -= DD->Zeilen - 1;
  1011.                                         DD = ( struct DisplayData * )DD->Node.ln_Pred;
  1012.                                     }
  1013.  
  1014.                                     DD = AktuDD;
  1015.                                     MoveStatusBalkenMaxOff = 0;
  1016.  
  1017.                                     while(DD != ( struct DisplayData *)&AktuDI->DisplayList.lh_Tail )
  1018.                                     {
  1019.                                         MoveStatusBalkenMaxOff += DD->Zeilen - 1;
  1020.                                         DD = ( struct DisplayData * )DD->Node.ln_Succ;
  1021.                                     }
  1022.                                 }
  1023.  
  1024.                                 if( MoveStatusBalkenY < MoveStatusBalkenMinOff )
  1025.                                      MoveStatusBalkenY = MoveStatusBalkenMinOff;
  1026.  
  1027.                                 if( MoveStatusBalkenY > MoveStatusBalkenMaxOff )
  1028.                                      MoveStatusBalkenY = MoveStatusBalkenMaxOff;
  1029.  
  1030.                                 InvertStatusBalkenRahmen( AktuDD, MoveStatusBalkenY );
  1031.                             }
  1032.                         }
  1033.                         else
  1034.                         {
  1035.                             static ULONG LastSeconds = 0, LastMicros = 0;
  1036.                             BOOL Doppel = FALSE;
  1037.                             long OldCPos;
  1038.                             struct DisplayData *OldDD;
  1039.                             
  1040.                                 /* Doppelklick testen */
  1041.                             
  1042.                             if( DoubleClick( LastSeconds, LastMicros, Msg.Seconds, Msg.Micros ))
  1043.                                 Doppel = TRUE;
  1044.                             
  1045.                             LastSeconds = Msg.Seconds;
  1046.                             LastMicros = Msg.Micros;
  1047.  
  1048.                             mainflags|=MF_LEFTMOUSEDOWN;
  1049.                             
  1050.                             OldCPos = AktuDD->CPos;
  1051.                             OldDD = AktuDD;
  1052.                             
  1053.                                 /* Prüfen, ob Cursor überhaupt irgendwo hingesetzt wurde */
  1054.                             
  1055.                             if( SetzeCursorMaus( Msg.MouseX, Msg.MouseY, NULL, AktuDI ))
  1056.                             {
  1057.                                 mainflags |= MF_MOVECURSOR;
  1058.                             
  1059.                                     /* Falls Doppelclick und Cursor an gleicher Stelle */
  1060.                             
  1061.                                 if( Doppel && ( AktuDD == OldDD ) && ( AktuDD->CPos == OldCPos ))
  1062.                                 {
  1063.                                     Mark( AktuDD );
  1064.                                 }
  1065.                             }
  1066.                         }
  1067.                         break;
  1068.                 }
  1069.                 break;
  1070.  
  1071.             case    IDCMP_INTUITICKS:
  1072.                 if( mainflags & MF_MOVECURSOR )
  1073.                     SetzeCursorMaus(Msg.MouseX,Msg.MouseY, AktuDD, AktuDI);
  1074.                 break;
  1075.  
  1076.             case    IDCMP_MENUPICK:
  1077.                 if( mainflags & MF_MOVESTATUSBALKEN )
  1078.                 {
  1079.                     InvertStatusBalkenRahmen( AktuDD, MoveStatusBalkenY );
  1080.                     mainflags &= ~MF_MOVESTATUSBALKEN;
  1081.                     ModifyIDCMP( AktuDI->Wnd, AktuDI->Wnd->IDCMPFlags | ( IDCMP_RAWKEY | IDCMP_VANILLAKEY ));
  1082.                 }
  1083.                 /*Stop = */DoMenu( &Msg );
  1084.                 break;
  1085.         }
  1086.     }
  1087. }
  1088.  
  1089. void DoAppWindowMessage( void )
  1090. {
  1091.     struct AppMessage *appMsg;
  1092.     long k;
  1093.  
  1094.     while(appMsg=(struct AppMessage *)GetMsg(AppPort))
  1095.     {
  1096.         if( appMsg->am_Type == 7 )        /* Icon ins Fenster gezogen */
  1097.         {
  1098.             struct WBArg *argptr;
  1099.             BOOL fertig=FALSE;
  1100.  
  1101.             argptr=appMsg->am_ArgList;
  1102.  
  1103.             for(k=0;(k<appMsg->am_NumArgs) && fertig==FALSE;k++,argptr++)
  1104.             {
  1105.                 if(strlen(argptr->wa_Name))
  1106.                 {
  1107.                     struct DisplayData *DD;
  1108.                     UBYTE buffer[256];
  1109.  
  1110.                     NameFromLock(argptr->wa_Lock,buffer,256);
  1111.  
  1112.                     AddPart(buffer,argptr->wa_Name,256);
  1113.  
  1114.                     MyActivateWindow(( struct DisplayInhalt * )appMsg->am_UserData );
  1115.                     ActivateWindow( AktuDI->Wnd );
  1116.  
  1117.                     if( DD = GetroffenerView(appMsg->am_MouseX,appMsg->am_MouseY,AktuDI))
  1118.                         ChangeAktuView( DD );
  1119.  
  1120.                     MyOpen(buffer, AktuDD);
  1121.  
  1122.                     fertig=TRUE;
  1123.                 }
  1124.             }
  1125.         }
  1126.  
  1127.         ReplyMsg((struct Message *)appMsg);
  1128.     }
  1129. }
  1130.  
  1131. void DoARexxMsg( void )
  1132. {
  1133. #ifdef AREXX
  1134.     ARexxDispatch( MyRexxHost );
  1135. #endif
  1136. }
  1137.  
  1138. static struct RDArgs *cliargs;
  1139. static struct MyArgs
  1140. {
  1141.     UBYTE *ma_PublicScreenName;
  1142.     UBYTE *ma_ArexxPortName;
  1143.     UBYTE *ma_ArexxStartupScript;
  1144.     UBYTE *ma_SettingsName;
  1145.     UBYTE *ma_CommandsName;
  1146.     UBYTE *ma_LanguageName;
  1147.     UBYTE *ma_KeyName;
  1148.     LONG ma_Sync;
  1149.     UBYTE *ma_FileName;
  1150. } myargs = { 0,0,0,0,0,0,0,0 };
  1151.  
  1152. struct DiskObject *dob;
  1153.  
  1154. char *ParseArgsAndAllocThings( void )
  1155. {
  1156.     char *errorstring;
  1157.     char *String;
  1158.     long k;
  1159.  
  1160.         /* Locale Initialisierungen */
  1161.  
  1162.     String = 0;
  1163.  
  1164.     if( cliargs )
  1165.     {
  1166.         if( myargs.ma_LanguageName )
  1167.         {
  1168.             String = myargs.ma_LanguageName;
  1169.         }
  1170.     }
  1171.     else if( dob )
  1172.     {
  1173.         String = FindToolType( dob->do_ToolTypes, "LANGUAGE" );
  1174.     }
  1175.  
  1176.     if(LocaleBase)
  1177.     {
  1178.         if(!(Locale = OpenLocale( 0 )))
  1179.         {
  1180.             Fault(IoErr(),"FileX",errorbuffer, 256);
  1181.             return(errorbuffer);
  1182.         }
  1183.  
  1184.         Catalog = OpenCatalog(Locale, "FileX.catalog", OC_BuiltInLanguage, "english", OC_Version, 2,(String ? OC_Language : TAG_DONE ), String, TAG_DONE );
  1185.     }
  1186.  
  1187.     LocalizeAll();
  1188.  
  1189.  
  1190.         /* Allgemeine Initialisierung, unabhängig von Argumenten */
  1191.  
  1192.     strcpy( DefaultFontName, GfxBase->DefaultFont->tf_Message.mn_Node.ln_Name );
  1193.     DefaultFontSize = GfxBase->DefaultFont->tf_YSize;
  1194.  
  1195.     Kick30 = ( SysBase->LibNode.lib_Version >= 39 );
  1196.  
  1197.     if( !( TextLineBuffer = AllocVec( TEXTLINEBUFFERLEN, MEMF_ANY)))
  1198.         return( GetStr( MSG_INFO_GLOBAL_CANTALLOCSOMEMEM ));
  1199.  
  1200.         /* Windowdefinitionsstrings allokieren */
  1201.  
  1202.     if(!(arexxcommandshellwindow = AllocVec(strlen(DEFAULT_COMMANDSHELLWINDOW) + 1,MEMF_ANY)))
  1203.         return(GetStr(MSG_INFO_GLOBAL_CANTALLOCSOMEMEM));
  1204.  
  1205.     strcpy(arexxcommandshellwindow,DEFAULT_COMMANDSHELLWINDOW);
  1206.  
  1207.     if(!(arexxcommandwindow = AllocVec(strlen(DEFAULT_COMMANDWINDOW) + 1,MEMF_ANY)))
  1208.         return(GetStr(MSG_INFO_GLOBAL_CANTALLOCSOMEMEM));
  1209.  
  1210.     strcpy(arexxcommandwindow,DEFAULT_COMMANDWINDOW);
  1211.  
  1212.         /* ARexxCommandos im Menu auf 'leer` setzen */
  1213.  
  1214.     for( k = 0; k < 10; k++ )
  1215.         SetEmptyARexxMenu( k );
  1216.  
  1217.         /* ReplyPort für Beantwortung eigener Msgs einrichten */
  1218.  
  1219.     if( !InitReplyPort())
  1220.         return( GetStr( MSG_INFO_GLOBAL_CANTCREATEMSGPORT ));
  1221.  
  1222.         /* Start Taskpriority bestimmen */
  1223.  
  1224.     oldtaskpri = taskpri = FindTask( NULL )->tc_Node.ln_Pri;
  1225.  
  1226.     InitSearchHistory();
  1227.  
  1228.     if( errorstring = AllocRequester())
  1229.         return( errorstring );
  1230.  
  1231.         /* Einen Windowport für alle IDCMP-Nachtrichten einrichten */
  1232.  
  1233.     if(WndPort=CreateMsgPort())
  1234.     {
  1235.         MyAddSignal( 1L << WndPort->mp_SigBit, &DoFileXWindowMessage);
  1236.     }
  1237.             /* AppMessagePort erstellen */
  1238.  
  1239.     if(AppPort=CreateMsgPort())
  1240.     {
  1241.         MyAddSignal( 1L << AppPort->mp_SigBit, &DoAppWindowMessage);
  1242.     }
  1243.  
  1244.  
  1245.         /* Settings laden. */
  1246.  
  1247.     if( cliargs )
  1248.     {
  1249.         if(myargs.ma_SettingsName)
  1250.         {
  1251.             if(!LoadSettings(myargs.ma_SettingsName,TRUE))LoadSettingsDefault();
  1252.         }
  1253.         else
  1254.             LoadSettingsDefault();
  1255.     }
  1256.     else if( dob )    
  1257.     {
  1258.         if(String=FindToolType(dob->do_ToolTypes,"SETTINGS"))
  1259.         {
  1260.             if(!LoadSettings(String,TRUE))LoadSettingsDefault();
  1261.         }
  1262.         else
  1263.             LoadSettingsDefault();
  1264.     }
  1265.  
  1266.         /* Verwaltungsstruckturen init */
  1267.  
  1268.     AktuDI = AllocDI();
  1269.     AktuDD = AllocDD( AktuDI, AllocFD( FD_FILE ));
  1270.     AktuDI->AktuDD = AktuDD;
  1271.  
  1272.         /* Argumentparsing und entsprechende Initialisierungen */
  1273.  
  1274.     if( cliargs )
  1275.     {
  1276.         if(myargs.ma_CommandsName)
  1277.         {
  1278.             if(!LoadARexxCommands(myargs.ma_CommandsName))
  1279.                 LoadARexxCommandsDefault();
  1280.         }
  1281.         else
  1282.             LoadARexxCommandsDefault();
  1283. /* Removed by Pavel Fedin    
  1284.         if(myargs.ma_KeyName)
  1285.         {
  1286.             if( !LoadKeyFile( myargs.ma_KeyName ))
  1287.                 if( !LoadKeyFile( "PROGDIR:filex.key" ))
  1288.                     if( !LoadKeyFile( "l:filex.key" ))
  1289.                         LoadKeyFile( "s:filex.key" );
  1290.         }
  1291.         else
  1292.             if( !LoadKeyFile( "PROGDIR:filex.key" ))
  1293.                 if( !LoadKeyFile( "l:filex.key" ))
  1294.                     LoadKeyFile( "s:filex.key" );*/
  1295.     
  1296.         if( myargs.ma_PublicScreenName )
  1297.         {
  1298.             SetScreenTypePublic( myargs.ma_PublicScreenName );
  1299.         }
  1300.     
  1301.         if(myargs.ma_FileName)
  1302.         {
  1303.             MyOpen(myargs.ma_FileName, AktuDD);
  1304.         }
  1305.  
  1306.         if(myargs.ma_ArexxStartupScript)
  1307.         {
  1308.             if(startuparexxscript = AllocVec(strlen(myargs.ma_ArexxStartupScript)+1,MEMF_ANY))
  1309.                 strcpy(startuparexxscript,myargs.ma_ArexxStartupScript);
  1310.         }
  1311.     }
  1312.     else if( dob )    
  1313.     {
  1314.         if(String=FindToolType(dob->do_ToolTypes,"COMMANDS"))
  1315.         {
  1316.             if(!LoadARexxCommands(String))
  1317.                 LoadARexxCommandsDefault();
  1318.         }
  1319.         else
  1320.             LoadARexxCommandsDefault();
  1321. /* Removed by Pavel Fedin
  1322.         if(String=FindToolType(dob->do_ToolTypes,"KEY"))
  1323.         {
  1324.             if( !LoadKeyFile( String ))
  1325.                 if( !LoadKeyFile( "PROGDIR:filex.key" ))
  1326.                     if( !LoadKeyFile( "l:filex.key" ))
  1327.                         LoadKeyFile( "s:filex.key" );
  1328.         }
  1329.         else
  1330.             if( !LoadKeyFile( "PROGDIR:filex.key" ))
  1331.                 if( !LoadKeyFile( "l:filex.key" ))
  1332.                     LoadKeyFile( "s:filex.key" );*/
  1333.  
  1334.         if(String=FindToolType(dob->do_ToolTypes,"PUBSCREENNAME"))
  1335.         {
  1336.             SetScreenTypePublic( myargs.ma_PublicScreenName );
  1337.         }
  1338.  
  1339.         if(String=FindToolType(dob->do_ToolTypes,"FILE"))
  1340.         {
  1341.             MyOpen(String,AktuDD);
  1342.         }
  1343.  
  1344.         if(String=FindToolType(dob->do_ToolTypes,"STARTUP"))
  1345.         {
  1346.             if(startuparexxscript = AllocVec(strlen(String)+1,MEMF_ANY))
  1347.                 strcpy(startuparexxscript,String);
  1348.         }
  1349.     }
  1350.  
  1351. #ifdef AREXX
  1352.         /* ARexx Setup */
  1353.  
  1354.     String = 0;
  1355.  
  1356.     if( cliargs )
  1357.         String = myargs.ma_ArexxPortName;
  1358.     else if( dob )
  1359.         String = FindToolType( dob->do_ToolTypes,"PORTNAME" );
  1360.  
  1361.     if( !( MyRexxHost = SetupARexxHost( String, NULL )))
  1362.         return(GetStr(MSG_INFO_AREXX_CANTSETUPAREXXHOST));
  1363.  
  1364.     MyAddSignal( 1L << MyRexxHost->port->mp_SigBit, &DoARexxMsg);
  1365.  
  1366.         /* ID von FileX anhand des ARexxportnamens bestimmen */
  1367.  
  1368.     {
  1369.         long k;
  1370.         for(k=0;(k<strlen(MyRexxHost->portname))&&(MyRexxHost->portname[k]!='.');k++);
  1371.  
  1372.         if(MyRexxHost->portname[k]=='.')
  1373.         {
  1374.             stcd_l(&MyRexxHost->portname[k+1],&filexid);
  1375.         }
  1376.         else
  1377.             filexid=0;
  1378.     }
  1379.  
  1380. #else
  1381.  
  1382.     filexid = 0;
  1383.  
  1384. #endif    /* AREXX */
  1385.  
  1386.         /* Alles wieder freigeben */
  1387.  
  1388.     if( cliargs )
  1389.         FreeArgs( cliargs );
  1390.     else
  1391.         if( dob )
  1392.             FreeDiskObject(dob);
  1393.  
  1394.     return( NULL );
  1395. }
  1396.  
  1397. void __saveds NewTaskStart( void )
  1398. {
  1399.     char *errorstring;
  1400.  
  1401.     if( errorstring = ParseArgsAndAllocThings())
  1402.     {
  1403.         MyRequestNoLocale( errorstring , 0 );
  1404.     }
  1405.     else
  1406.     {
  1407. /* Removed registration stuff - Pavel Fedin
  1408.         if( 1 != ChecksumCorrect())
  1409.             Gedenken();*/
  1410.  
  1411.         DoWindow();
  1412.     }
  1413. }
  1414.  
  1415.     /* ProcessCleanup(register __d1 BPTR SegList):
  1416.      *
  1417.      *    Frees all resource the main process has allocated when
  1418.      *    it exits.
  1419.      */
  1420.  
  1421. STATIC VOID __saveds __asm
  1422. ProcessCleanup(register __d1 BPTR SegList)
  1423. {
  1424.     CloseAll();
  1425.  
  1426.     Forbid();
  1427.  
  1428.     UnLoadSeg(SegList);
  1429.  
  1430.     CloseLibs();
  1431. }
  1432.  
  1433.     /* SegmentSplit(STRPTR Name,BYTE Pri,LONG StackSize,APTR Function):
  1434.      *
  1435.      *    Create a new process from the current one.
  1436.      */
  1437.  
  1438. STATIC struct Process *
  1439. SegmentSplit(STRPTR Name,LONG StackSize,APTR Function)
  1440. {
  1441.     struct Process            *Child;
  1442.     struct CommandLineInterface    *CLI;
  1443.  
  1444.     CLI = (struct CommandLineInterface *)BADDR(((struct Process *)SysBase -> ThisTask) -> pr_CLI);
  1445.  
  1446.     Forbid();
  1447.  
  1448.     Child = CreateNewProcTags(
  1449.         NP_CommandName,    (LONG)"FileX",
  1450.         NP_Name,    Name,
  1451.         NP_StackSize,    StackSize,
  1452.         NP_Entry,    Function,
  1453.         NP_Cli,        TRUE,
  1454.         NP_ExitCode,    ProcessCleanup,
  1455.         NP_ExitData,    CLI->cli_Module,
  1456.     TAG_DONE);
  1457.  
  1458.     if(Child)
  1459.         CLI -> cli_Module = NULL;
  1460.  
  1461.     Permit();
  1462.  
  1463.     return(Child);
  1464. }
  1465.  
  1466. LONG main(void)
  1467. {
  1468.     UBYTE *errorstring;
  1469.     struct Process *myproc;
  1470.  
  1471.     myproc = (struct Process *)SysBase -> ThisTask;
  1472.  
  1473.     if( myproc->pr_CLI )
  1474.     {
  1475.             /* Clistart */
  1476.  
  1477.         if(errorstring = OpenLibs())
  1478.         {
  1479.             if( ReqToolsBase || IntuitionBase )
  1480.                 MyRequestNoLocale( errorstring , 0 );
  1481.             else
  1482.                 Printf( "%s\n", errorstring );
  1483.  
  1484.             CloseLibs();
  1485.             return(RETURN_FAIL);
  1486.         }
  1487.  
  1488.             /* Programmnamen bestimmen */
  1489.  
  1490.         GetProgramName(programname,256);
  1491.  
  1492.         if(!(cliargs=ReadArgs("PUBSCREEN/K,PORTNAME/K,STARTUP/K,SETTINGS/K,COMMANDS/K,LANGUAGE/K,KEY/K,SYNC/S,FILE",(LONG *)&myargs,0)))
  1493.         {
  1494.             PrintFault( IoErr(), "FileX");
  1495.             CloseLibs();
  1496.             return(RETURN_FAIL);
  1497.         }
  1498.  
  1499.         if(!myargs.ma_Sync)
  1500.         {
  1501.                 /* Create a new process from our code. */
  1502.  
  1503.             if(!SegmentSplit("FileX",16384,NewTaskStart))
  1504.             {
  1505.                 Printf(GetStr(MSG_INFO_GLOBAL_FAILEDTOCREATEPROCESS));
  1506.  
  1507.                 return(RETURN_FAIL);
  1508.             }
  1509.         }
  1510.         else
  1511.         {
  1512.             if( errorstring = ParseArgsAndAllocThings())
  1513.                 MyRequestNoLocale( errorstring , 0 );
  1514.             else
  1515.             {
  1516. /* Removed registration stuff - Pavel Fedin
  1517.                 if( 1 != ChecksumCorrect())
  1518.                     Gedenken();*/
  1519.  
  1520.                 DoWindow();
  1521.             }
  1522.  
  1523.             CloseAll();
  1524.             CloseLibs();
  1525.         }
  1526.     }
  1527.     else
  1528.     {
  1529.         struct WBArg *wbarg;
  1530.         struct WBStartup        *WBenchMsg;
  1531.         BPTR WBStartLock;                /* Lock der auf das aktuelle Verzeichnis */
  1532.                                             /* beim Start von der Workbench zeigt */
  1533.  
  1534.         WaitPort(&myproc->pr_MsgPort);
  1535.         WBenchMsg = (struct WBStartup *)GetMsg(&myproc->pr_MsgPort);
  1536.  
  1537.         if(errorstring=OpenLibs())
  1538.         {
  1539.             if( ReqToolsBase || IntuitionBase )
  1540.                 MyRequestNoLocale( errorstring , 0 );
  1541.             else
  1542.                 Printf( "%s\n", errorstring );
  1543.  
  1544.             CloseLibs();
  1545.             return(RETURN_FAIL);
  1546.         }
  1547.  
  1548.         WBStartLock = CurrentDir(WBenchMsg->sm_ArgList->wa_Lock);
  1549.  
  1550.         wbarg=WBenchMsg->sm_ArgList;
  1551.  
  1552.         NameFromLock(wbarg->wa_Lock,programname,256);
  1553.         AddPart(programname,wbarg->wa_Name,256);
  1554.  
  1555.         dob = GetDiskObject(programname);
  1556.  
  1557.         if( errorstring = ParseArgsAndAllocThings())
  1558.             MyRequestNoLocale( errorstring , 0 );
  1559.         else
  1560.         {
  1561. /* Removed registration stuff - Pavel Fedin
  1562.             if( 1 != ChecksumCorrect())
  1563.                 Gedenken();*/
  1564.  
  1565.             if(WBenchMsg->sm_NumArgs > 1)
  1566.             {
  1567.                 CurrentDir((WBenchMsg->sm_ArgList + 1)->wa_Lock);
  1568.  
  1569.                 MyOpen((WBenchMsg->sm_ArgList + 1)->wa_Name, AktuDD);
  1570.             }
  1571.  
  1572.             DoWindow();
  1573.         }
  1574.  
  1575.         CurrentDir(WBStartLock);
  1576.  
  1577.         CloseAll();
  1578.         CloseLibs();
  1579.  
  1580.         Forbid();
  1581.  
  1582.         ReplyMsg((struct Message *)WBenchMsg);
  1583.     }
  1584.  
  1585.     return(RETURN_OK);
  1586. }
  1587.  
  1588. void About(void)
  1589. {
  1590.  
  1591. #ifdef __M68020
  1592. #define CPUSTRING "68020"
  1593. #else
  1594. #define CPUSTRING "68000"
  1595. #endif
  1596.  
  1597.     if( 1 == MyFullRequest( MSG_INFO_GLOBAL_ABOUTTEXT1, MSG_GADGET_ABOUT1, CPUSTRING ,VSTRING, DATE ))
  1598.     MyFullRequest( MSG_INFO_GLOBAL_ABOUTTEXT2, MSG_GADGET_ABOUT2, 0 );
  1599. /*    if( 1 == MyFullRequest( MSG_INFO_GLOBAL_ABOUTTEXT2, MSG_GADGET_ABOUT2, 0 ))
  1600.     {
  1601.         if( regname[0] )
  1602.             MyFullRequest( MSG_INFO_GLOBAL_REGISTERED, MSG_GADGET_REGISTERED, regnum, regname );
  1603.         else
  1604.              MyFullRequest( MSG_INFO_GLOBAL_NOTREGISTERED, MSG_GADGET_REGISTERED, 0 );
  1605.     }*/
  1606. }
  1607.  
  1608. void MyBeep(void)
  1609. {
  1610.     DisplayBeep(Scr);
  1611. }
  1612.  
  1613. /*
  1614.  * BOOL LoadUserDisplaytyp(char *fullname)
  1615.  *
  1616.  * Öffnet einen FileRequester und läd einen userdefined Displaytyp ein
  1617.  */
  1618.  
  1619. BOOL LoadUserDisplaytyp(char *fullname)
  1620. {
  1621.     BPTR fh;
  1622.     BOOL Success=FALSE;
  1623.  
  1624.     if(fh=Open(fullname,MODE_OLDFILE))
  1625.     {
  1626.         Read(fh,displaytab[3],256);
  1627.  
  1628.         SetDisplayTyp(3, AktuDD );
  1629.  
  1630.         Success=TRUE;
  1631.  
  1632.         Close(fh);
  1633.     }
  1634.     else
  1635.         MyRequest( MSG_INFO_GLOBAL_CANTOPENFILE, ( ULONG )fullname );
  1636.  
  1637.     return(Success);
  1638. }
  1639.  
  1640. /*
  1641.  * BOOL LoadUserDisplaytypFR(void)
  1642.  *
  1643.  * Öffnet einen FileRequester und läd einen userdefined Displaytyp ein
  1644.  */
  1645.  
  1646. BOOL LoadUserDisplaytypFR(void)
  1647. {
  1648.     static UBYTE DisplaytypFullName[256];
  1649.  
  1650.     if( MyRequestFile( DisplaytypFullName, GetStr(MSG_WINDOWTITLE_SELECTDISPLAYFILE), 0, FALSE ))
  1651.         return( LoadUserDisplaytyp( DisplaytypFullName ));
  1652.     else
  1653.         return( FALSE );
  1654. }
  1655.  
  1656. /*
  1657.  * void SetScrollerGadget(void)
  1658.  *
  1659.  * Setz das Scrollergadget auf den richtigen Wert, d.h.
  1660.  * laenge+DD->Zeilen => Größe des Knobs
  1661.  * ScrollerPos => Position
  1662.  */
  1663.  
  1664. void SetScrollerGadget( struct DisplayData *DD )
  1665. {
  1666.     LONG Gesamtzeilen=( DD->FD->Len + DD->BPR - 1 ) / DD->BPR - DD->Zeilen;
  1667.  
  1668.     if(Gesamtzeilen<65000)
  1669.         SetGadgetAttrs(DD->PropGadget,DD->DI->Wnd,0,
  1670.                     PGA_Total,(Gesamtzeilen < 0) ? 0 : Gesamtzeilen+DD->Zeilen,
  1671.                     PGA_Top,(ULONG)DD->SPos,
  1672.                     PGA_Visible,DD->Zeilen,
  1673.                     TAG_DONE);
  1674.     else
  1675.     {
  1676.         SetGadgetAttrs(DD->PropGadget,DD->DI->Wnd,0,
  1677.                     PGA_Total,65001,
  1678.                     PGA_Top,(ULONG)DD->SPos*650/Gesamtzeilen*100,
  1679.                     PGA_Visible,1,
  1680.                     TAG_DONE);
  1681.     }
  1682. }
  1683.  
  1684. /*
  1685.  * long GetFileLaenge(BPTR fh)
  1686.  *
  1687.  * Ermittelt die Länge des Files mit der FileHandlestruktur fh
  1688.  * (Lange, aber schnelle Version)
  1689.  */
  1690.  
  1691. long GetFileLaenge(BPTR fh)
  1692. {
  1693.     struct FileInfoBlock *fib;
  1694.     LONG size=0;
  1695.  
  1696.     if(fib=(struct FileInfoBlock *)AllocDosObject(DOS_FIB,NULL))
  1697.     {
  1698.         ExamineFH(fh,fib);
  1699.  
  1700.         size=fib->fib_Size;
  1701.  
  1702.         FreeDosObject(DOS_FIB,fib);
  1703.     }
  1704.  
  1705.     return(size);
  1706. }
  1707.  
  1708. /*
  1709.  * long GetFileLaengeName(char *name)
  1710.  *
  1711.  * Ermittelt die Länge des Files mit dem Namen name
  1712.  * (Lange, aber schnelle Version)
  1713.  */
  1714.  
  1715. long GetFileLaengeName(char *name)
  1716. {
  1717.     struct FileInfoBlock *fib;
  1718.     LONG size=0;
  1719.  
  1720.     if(fib=(struct FileInfoBlock *)AllocDosObject(DOS_FIB,NULL))
  1721.     {
  1722.         BPTR FileLock;
  1723.  
  1724.         if(FileLock = Lock(name,ACCESS_READ))
  1725.         {
  1726.             Examine(FileLock,fib);
  1727.  
  1728.             size=fib->fib_Size;
  1729.  
  1730.             UnLock(FileLock);
  1731.         }
  1732.  
  1733.         FreeDosObject(DOS_FIB,fib);
  1734.     }
  1735.  
  1736.     return(size);
  1737. }
  1738.  
  1739. void FreeNLNode( struct Node *node )
  1740. {
  1741.     if( node )
  1742.     {
  1743.         Remove( node );
  1744.         if( node ->ln_Name ) FreeMem(node->ln_Name,strlen(node->ln_Name)+1);
  1745.         FreeMem(node,sizeof(struct Node));
  1746.     }
  1747. }
  1748.  
  1749. void AddNLName( struct List *List, char *Name )
  1750. {
  1751.     struct Node *node;
  1752.  
  1753.     if( node = AllocMem( sizeof( struct Node ), MEMF_CLEAR ))
  1754.     {
  1755.         if( node->ln_Name = AllocMem( strlen( Name ) + 1, MEMF_ANY ))
  1756.             strcpy( node->ln_Name, Name );
  1757.  
  1758.         AddTail( List, node );
  1759.     }
  1760. }
  1761.  
  1762. struct FileData *AllocFD( WORD Typ )
  1763. {
  1764.     struct FileData *FD;
  1765.  
  1766.     if( FD = AllocVec( sizeof( struct FileData ), MEMF_CLEAR ))
  1767.     {
  1768.         AddTail( &FileList, &FD->Node );
  1769.  
  1770.         FD->Typ = Typ;
  1771.  
  1772.         NewList( &FD->DisplayList );
  1773.  
  1774.         if( FD->Name = AllocVec( 256, MEMF_CLEAR ))
  1775.         {
  1776.             if( AllocUndostructs( FD ))
  1777.             {
  1778.                 int k;
  1779.  
  1780.                 FD->LocationNumber = 1;
  1781.                 
  1782.                 for( k = 0; k < 10; k++ )
  1783.                     FD->Locations[ k ] = -1;
  1784.             }
  1785.             else
  1786.             {
  1787.                 FreeFD( FD );
  1788.                 FD = 0;
  1789.             }
  1790.         }
  1791.         else
  1792.         {
  1793.             FreeFD( FD );
  1794.             FD = 0;
  1795.         }
  1796.     }
  1797.  
  1798.     return( FD );
  1799. }
  1800.  
  1801. void FreeFD( struct FileData *FD )
  1802. {
  1803.     if( !FD )
  1804.         return;
  1805.  
  1806.     Remove( &FD->Node );
  1807.  
  1808.     if( FD->Name )
  1809.     {
  1810.         FreeVec( FD->Name );
  1811.         FD->Name = 0;
  1812.     }
  1813.  
  1814.     if( FD->Typ == FD_FILE )
  1815.     if( FD->Mem && FD->RLen )
  1816.     {
  1817.         FreeMem( FD->Mem, FD->RLen );
  1818.         FD->Mem = 0;
  1819.         FD->RLen = FD->Len = 0;
  1820.     }
  1821.  
  1822.     FreeUndostructs( FD );
  1823.     FreeVec( FD );
  1824. }
  1825.  
  1826. void FreeDD( struct DisplayData *DD )
  1827. {
  1828.     if( !DD )
  1829.         return;
  1830.  
  1831.     if( DD->PropGadget )
  1832.     {
  1833.         if( DD->Wnd )
  1834.             RemoveGadget( DD->Wnd, DD->PropGadget );
  1835.         
  1836.         DisposeObject((APTR) DD->PropGadget );
  1837.         DD->PropGadget = 0;
  1838.     }
  1839.  
  1840.     if( ElementZahl( &DD->FD->DisplayList ) == 1 )
  1841.         FreeFD( DD->FD );
  1842.     else
  1843.         Remove( &DD->FNode );
  1844.  
  1845.     Remove( &DD->Node );
  1846.  
  1847.     FreeVec( DD );
  1848. }
  1849.  
  1850. struct DisplayData *AllocDD( struct DisplayInhalt *DI, struct FileData *FD )
  1851. {
  1852.     struct DisplayData *DD;
  1853.  
  1854.     if( DD = AllocVec( sizeof( struct DisplayData ), MEMF_CLEAR ))
  1855.     {
  1856.             /* Defaultwerte setzen */
  1857.  
  1858.         DD->DisplayForm = DefaultDisplayForm;
  1859.         DD->DisplaySpaces = DefaultDisplaySpaces;
  1860.         DD->Zeilen = DefaultZeilen;
  1861.         DD->BPR = DefaultBPR;
  1862.         DD->DisplayTyp = DefaultDisplayTyp;
  1863.  
  1864.             /* andere Werte setzten */
  1865.  
  1866.         DD->Wnd = DI->Wnd;
  1867.         DD->FD = FD;
  1868.         DD->DI = DI;
  1869.  
  1870.         AddTail( &FD->DisplayList, &DD->FNode );
  1871.         AddTail( &DI->DisplayList, &DD->Node );
  1872.     }
  1873.  
  1874.     return( DD );
  1875. }
  1876.  
  1877. void FreeDI( struct DisplayInhalt *DI )
  1878. {
  1879.     if( !DI )
  1880.         return;
  1881.  
  1882.     while( !IsListEmpty( &DI->DisplayList ))
  1883.         FreeDD(( struct DisplayData * )DI->DisplayList.lh_Head );
  1884.  
  1885.     Remove( &DI->Node );
  1886.  
  1887.     FreeVec( DI );
  1888. }
  1889.  
  1890. struct DisplayInhalt *AllocDI( void )
  1891. {
  1892.     struct DisplayInhalt *DI;
  1893.  
  1894.     if( DI = AllocVec( sizeof( struct DisplayInhalt ), MEMF_CLEAR ))
  1895.     {
  1896.             /* Defaultfont setzen */
  1897.  
  1898.         MySetFontNameSize( DefaultFontName, DefaultFontSize, DI );
  1899.  
  1900.         DI->WindowTop = DefaultTop;
  1901.         DI->WindowLeft = DefaultLeft;
  1902.  
  1903.         AddTail( &DisplayInhaltList, &DI->Node );
  1904.         NewList( &DI->DisplayList );
  1905.     }
  1906.  
  1907.     return( DI );
  1908. }
  1909.  
  1910. BOOL MyOpen( char *Name, struct DisplayData *DD )
  1911. {
  1912.     BPTR fh;
  1913.     BOOL Success=FALSE;
  1914.     struct FileData *FD;
  1915.  
  1916.     FD = DD->FD;
  1917.  
  1918.     if( !IsListEmpty( &OldFileList ))
  1919.     {
  1920.         if( !FindName( &OldFileList, Name ))
  1921.             AddNLName( &OldFileList, Name);
  1922.     }
  1923.     else
  1924.         AddNLName( &OldFileList, Name);
  1925.  
  1926.         /* File versuchen zu öffnen */
  1927.  
  1928.     fh = Open( Name , MODE_OLDFILE );
  1929.  
  1930.     if( ElementZahl( &FD->DisplayList ) == 1 )
  1931.         FreeFD( FD );
  1932.     else
  1933.         Remove( &DD->FNode );
  1934.  
  1935.     FD = AllocFD( FD_FILE );
  1936.     AddTail( &FD->DisplayList, &DD->FNode );
  1937.     DD->FD = FD;
  1938.  
  1939.     if( fh )
  1940.     {
  1941.         FD->RLen = FD->Len = GetFileLaenge( fh );
  1942.  
  1943.             /* Prüfen, ob das File einen Inhalt hat */
  1944.  
  1945.         if( FD->RLen )
  1946.         {
  1947.             if( FD->Mem = AllocMem( FD->Len, MEMF_ANY ))
  1948.             {
  1949.                 if( FD->Len == Read( fh, FD->Mem, FD->RLen ))
  1950.                     Success = TRUE;
  1951.             }
  1952.             else
  1953.             {
  1954.                 MyRequest( MSG_INFO_GLOBAL_CANTALLOCMEM, FD->Len );
  1955.                 FD->RLen = FD->Len = 0;
  1956.             }
  1957.         }
  1958.     }
  1959.  
  1960.         /* Falls File nicht geöffnet werden konnte oder Länge 0,
  1961.          * einen Dummyeintrag erzeugen */
  1962.  
  1963.     if( !fh || !FD->RLen )
  1964.     {
  1965.             /* Das File ist leer. Trotzdem ein Byte allokieren, */
  1966.             /* damit es eingeladen werden kann. */
  1967.  
  1968.         FD->Len = 0;
  1969.         FD->RLen = 1;
  1970.  
  1971.         if( FD->Mem = AllocMem( FD->RLen, MEMF_ANY ))
  1972.         {
  1973.             Success = TRUE;
  1974.         }
  1975.         else
  1976.         {
  1977.             MyRequest( MSG_INFO_GLOBAL_CANTALLOCMEM, FD->Len );
  1978.             FD->RLen = FD->Len = 0;
  1979.         }
  1980.     }
  1981.  
  1982.     strcpy( FD->Name, Name );
  1983.  
  1984.         /* Falls das Window geöffnet ist, alles neudarstellen */
  1985.  
  1986.     if( DD->DI->Wnd )
  1987.     {
  1988.         CursorOff( DD );
  1989.         DD->SPos = 0;
  1990.         SetScrollerGadget( DD );
  1991.         RedrawDisplay( DD );
  1992.         DD->CPos = 0;
  1993.         CursorOn( DD );
  1994.         UpdateStatusZeile( DD );
  1995.     }
  1996.  
  1997.     if( fh )
  1998.         Close( fh );
  1999.  
  2000.     if( !Success )
  2001.         ClearDDFile( DD, TRUE );
  2002.  
  2003.     return( Success );
  2004. }
  2005.  
  2006. BOOL FileLoaded( struct FileData *FD )
  2007. {
  2008.     return(( BOOL )*FilePart( FD->Name ));
  2009. }
  2010.  
  2011. void PrintFile( struct FileData * FD )
  2012. {
  2013.     struct DisplayData *FirstDD;
  2014.  
  2015.     FirstDD = GetDDFromFD( FD->DisplayList.lh_Head );
  2016.  
  2017.     MyPrint( FD->Mem, FD->Len, FirstDD->DisplayTyp, FirstDD->DI->Wnd );
  2018. }
  2019.  
  2020. BOOL SaveFile( struct FileData *FD )
  2021. {
  2022.     if( *FilePart( FD->Name ))
  2023.         return( Save( FD ));
  2024.     else
  2025.         return( SaveAsFile( FD ));
  2026. }
  2027.  
  2028. BOOL OpenFile( struct DisplayData *DD )
  2029. {
  2030.     char Buffer[ 256 ];
  2031.  
  2032.     strcpy( Buffer, DD->FD->Name );
  2033.  
  2034.     if( MyRequestFile( Buffer, GetStr(MSG_WINDOWTITLE_OPENFILE), 0, TRUE ))
  2035.         return( MyOpen( Buffer, DD ));
  2036.     else
  2037.         return( FALSE );
  2038. }
  2039.  
  2040. void ClearDDFile( struct DisplayData *DD, BOOL Force )
  2041. {
  2042.     struct FileData *FD;
  2043.  
  2044.     if( Force || QuitView( 3, DD ))
  2045.     {
  2046.         FD = AllocFD( FD_FILE );
  2047.     
  2048.         strcpy( FD->Name, DD->FD->Name );
  2049.         *FilePart( FD->Name ) = 0;
  2050.     
  2051.         if( ElementZahl( &DD->FD->DisplayList ) == 1 )
  2052.             FreeFD( DD->FD );
  2053.         else
  2054.             Remove( &DD->FNode );
  2055.     
  2056.         DD->FD = FD;
  2057.         DD->CPos = 0;
  2058.     
  2059.         AddTail( &FD->DisplayList, &DD->FNode );
  2060.     
  2061.         if( DD->Wnd )
  2062.         {
  2063.             CursorOff( DD );
  2064.             UpdateStatusZeile( DD );
  2065.             SetScrollerGadget( DD );
  2066.             RedrawDisplay( DD );
  2067.         }
  2068.     }
  2069. }
  2070.  
  2071. BOOL SaveNewName( char *name, struct FileData *FD )
  2072. {
  2073.     strcpy( FD->Name, name );
  2074.     return( Save( FD ));
  2075. }
  2076.  
  2077. BOOL Save( struct FileData *FD )
  2078. {
  2079.     BPTR fh;
  2080.     BOOL Success=FALSE;
  2081.  
  2082.         /* Prüfen, ob File existiert. Falls ja, fragen, ob es überschrieben */
  2083.         /* werden soll */
  2084.  
  2085.     if(!(mainflags&MF_OVERWRITE))
  2086.         if(GetFileLaengeName(FD->Name))
  2087.             if(0 == MyFullRequest( MSG_INFO_GLOBAL_FILEALREADYEXISTS, MSG_GADGET_YESNO, ( ULONG )FD->Name ))
  2088.                 return(Success);
  2089.  
  2090.     if(fh=Open(FD->Name,MODE_NEWFILE))
  2091.     {
  2092.         if(FD->Len!=Write(fh,FD->Mem,FD->Len))
  2093.         {
  2094.                         /* Falls nicht vollständig geschrieben, löschen */
  2095.  
  2096.             Close( fh );
  2097.             MyRequest( MSG_INFO_GLOBAL_CANTSAVEFILE, ( ULONG )FD->Name );
  2098.             DeleteFile( FD->Name );
  2099.         }
  2100.         else
  2101.         {
  2102.             FD->FullChanges=FD->RedoChanges=FD->Changes=0;
  2103.             Close(fh);
  2104.  
  2105.             UpdateAllStatusZeilen( FD );
  2106.         
  2107.             Success=TRUE;
  2108.         }
  2109.     }
  2110.     else
  2111.         MyRequest( MSG_INFO_GLOBAL_CANTSAVEFILE, ( ULONG )FD->Name );
  2112.  
  2113.     return(Success);
  2114. }
  2115.  
  2116. void UpdateAllStatusZeilen( struct FileData *FD )
  2117. {
  2118.     struct DisplayData *DD;
  2119.  
  2120.         /* Alle Statuszeilen des File neuzeichnen */
  2121.  
  2122.     DD = GetDDFromFD( FD->DisplayList.lh_Head );
  2123.  
  2124.     while( DD != GetDDFromFD( &FD->DisplayList.lh_Tail ))
  2125.     {
  2126.         UpdateStatusZeile( DD );
  2127.  
  2128.         DD = GetDDFromFD( DD->FNode.ln_Succ );
  2129.     }
  2130. }
  2131.  
  2132. BOOL SaveAsFile( struct FileData *FD )
  2133. {
  2134.     if( MyRequestFile( FD->Name, GetStr(MSG_WINDOWTITLE_SAVEFILEAS ), 0, TRUE ))
  2135.     {
  2136.         return( Save( FD ));
  2137.     }
  2138.     else
  2139.         return( FALSE );
  2140. }
  2141.  
  2142. void DisplayFromScroller( struct DisplayData *DD )
  2143. {
  2144.     ULONG newasp,cdisp,oldasp=DD->SPos,oldpos=DD->CPos;
  2145.  
  2146.     GetAttr(PGA_Top,(APTR)DD->PropGadget,&newasp);
  2147.  
  2148. #ifdef DEBUG
  2149.     Printf("DD->BPR=%ld\n",(LONG)DD->BPR);
  2150.     Printf("newasp=%lu\n",newasp);
  2151. #endif
  2152. /*    Sorry, i did not understand this - Pavel Fedin
  2153.     if((DD->FD->Len+DD->BPR-1)/DD->BPR-DD->Zeilen>=65000)
  2154.         newasp=newasp/650*(((DD->FD->Len+DD->BPR-1)/DD->BPR)-DD->Zeilen)/100;
  2155.     
  2156.     DD->CPos += ( newasp - oldasp ) * DD->BPR;
  2157.  
  2158.     The following is my version */
  2159.     cdisp=oldpos-oldasp*DD->BPR;
  2160.     DD->SPos=newasp;
  2161.     DD->CPos=newasp*DD->BPR+cdisp;    // Äîäåëàòü ïåðåìåùåíèå êóðñîðà
  2162.  
  2163.     UpdateStatusZeile( DD );
  2164.     RedrawDisplay( DD );
  2165.     if (DD->Flags&DD_MARK)
  2166.         ChangeMark(oldpos,DD->CPos,oldasp,DD->SPos, DD);
  2167. //    else
  2168.         CursorOn(DD);
  2169. }
  2170.  
  2171. void Mark( struct DisplayData *DD )
  2172. {
  2173.     if(DD->FD->Len!=0)
  2174.     if(DD->Flags&DD_MARK)
  2175.     {
  2176.         DD->Flags&=~DD_MARK;
  2177.         MarkOff( DD );
  2178.         CursorOn( DD );
  2179.     }
  2180.     else
  2181.     {
  2182.         DD->Flags|=DD_MARK;
  2183.         DD->MPos = DD->CPos;
  2184.  
  2185.         MarkOn( DD );
  2186.     }
  2187. }
  2188.  
  2189. void Palette(void)
  2190. {
  2191.     if( ReqToolsBase )
  2192.     {
  2193.         if(rtPaletteRequest(GetStr(MSG_WINDOWTITLE_PALETTE),NULL,AktuDI->Wnd ? RT_Window : TAG_IGNORE, AktuDI->Wnd,TAG_DONE))
  2194.         {
  2195.             ULONG k,color;
  2196.     
  2197.             for(k=0;k<8;k++)
  2198.             {
  2199.                 color=GetRGB4(Scr->ViewPort.ColorMap,k);
  2200.                 ScreenColors[k].ColorIndex=k;
  2201.                 ScreenColors[k].Red  =(color >> 8)&0xf;
  2202.                 ScreenColors[k].Green=(color >> 4)&0xf;
  2203.                 ScreenColors[k].Blue =(color     )&0xf;
  2204.             }
  2205.         }
  2206.     }
  2207.     else
  2208.         DisplayLocaleText( MSG_INFO_GLOBAL_REQTOOLSLIBRARYREQUIRED );
  2209. }
  2210.  
  2211. /*void PrintIntuiMessage( struct IntuiMessage *m )
  2212. {
  2213.     char *classstring;
  2214.  
  2215.     if( m->Class == IDCMP_INTUITICKS ) return;
  2216.  
  2217.     switch( m->Class )
  2218.     {
  2219.         case IDCMP_SIZEVERIFY:
  2220.             classstring = "SIZEVERIFY";
  2221.             break;
  2222.         case IDCMP_NEWSIZE:
  2223.             classstring = "NEWSIZE";
  2224.             break;
  2225.         case IDCMP_REFRESHWINDOW:
  2226.             classstring = "REFRESHWINDOW";
  2227.             break;
  2228.         case IDCMP_MOUSEBUTTONS:
  2229.             classstring = "MOUSEBUTTONS";
  2230.             break;
  2231.         case IDCMP_MOUSEMOVE:
  2232.             classstring = "MOUSEMOVE";
  2233.             break;
  2234.         case IDCMP_GADGETDOWN:
  2235.             classstring = "GADGETDOWN";
  2236.             break;
  2237.         case IDCMP_GADGETUP:
  2238.             classstring = "GADGETUP";
  2239.             break;
  2240.         case IDCMP_REQSET:
  2241.             classstring = "REQSET";
  2242.             break;
  2243.         case IDCMP_MENUPICK:
  2244.             classstring = "MENUPICK";
  2245.             break;
  2246.         case IDCMP_CLOSEWINDOW:
  2247.             classstring = "CLOSEWINDOW";
  2248.             break;
  2249.         case IDCMP_RAWKEY:
  2250.             classstring = "RAWKEY";
  2251.             break;
  2252.         case IDCMP_REQVERIFY:
  2253.             classstring = "REQVERIFY";
  2254.             break;
  2255.         case IDCMP_REQCLEAR:
  2256.             classstring = "REQCLEAR";
  2257.             break;
  2258.         case IDCMP_MENUVERIFY:
  2259.             classstring = "MENUVERIFY";
  2260.             break;
  2261.         case IDCMP_NEWPREFS:
  2262.             classstring = "NEWPREFS";
  2263.             break;
  2264.         case IDCMP_DISKINSERTED:
  2265.             classstring = "DISKINSERTED";
  2266.             break;
  2267.         case IDCMP_DISKREMOVED:
  2268.             classstring = "DISKREMOVED";
  2269.             break;
  2270.         case IDCMP_WBENCHMESSAGE:
  2271.             classstring = "WBENCHMESSAGE";
  2272.             break;
  2273.         case IDCMP_ACTIVEWINDOW:
  2274.             classstring = "ACTIVEWINDOW";
  2275.             break;
  2276.         case IDCMP_INACTIVEWINDOW:
  2277.             classstring = "INACTIVEWINDOW";
  2278.             break;
  2279.         case IDCMP_DELTAMOVE:
  2280.             classstring = "DELTAMOVE";
  2281.             break;
  2282.         case IDCMP_VANILLAKEY:
  2283.             classstring = "VANILLAKEY";
  2284.             break;
  2285.         case IDCMP_INTUITICKS:
  2286.             classstring = "INTUITICKS";
  2287.             break;
  2288.         case IDCMP_IDCMPUPDATE:
  2289.             classstring = "IDCMPUPDATE";
  2290.             break;
  2291.         case IDCMP_MENUHELP:
  2292.             classstring = "MENUHELP";
  2293.             break;
  2294.         case IDCMP_CHANGEWINDOW:
  2295.             classstring = "CHANGEWINDOW";
  2296.             break;
  2297.         case IDCMP_GADGETHELP:
  2298.             classstring = "GADGETHELP";
  2299.             break;
  2300.         defaul:
  2301.             classstring = "UNKNOWN";
  2302.     }
  2303. #ifdef DEBUG
  2304.     kprintf( "Class: %16s, Code: %4lx, Qual: %4lx, IAdr: %8lx\n",classstring, m->Code, m->Qualifier, m->IAddress);
  2305. #endif
  2306. }
  2307. */
  2308.  
  2309. static ULONG WaitSignals;
  2310. #define MAXSIGNALS 20
  2311. static void ( * SignalFunktionTab[ MAXSIGNALS ])( void );
  2312. static ULONG Signals[ MAXSIGNALS ];
  2313.  
  2314. void MyAddSignal( ULONG Signal, void ( * Funktion )())
  2315. {
  2316.     long k;
  2317.  
  2318. /*    kprintf("MyAddSignal(%8lx,%8lx)\n", Signal, Funktion );*/
  2319.  
  2320.     WaitSignals |= Signal;
  2321.  
  2322.     for( k = 0; k < MAXSIGNALS; k++ )
  2323.     {
  2324.         if( SignalFunktionTab[ k ] == 0)
  2325.         {
  2326.             SignalFunktionTab[ k ] = Funktion;
  2327.             Signals[ k ] = Signal;
  2328.             break;
  2329.         }
  2330.     }
  2331.  
  2332. /*    if( k == MAXSIGNALS )*/
  2333. /*        kprintf("Warnung!: Kein Platz mehr in Signalliste\n");*/
  2334. }
  2335.  
  2336. void MyRemoveSignal( ULONG Signal )
  2337. {
  2338.     long k;
  2339.     BOOL Found = FALSE;
  2340.  
  2341. /*    kprintf("MyRemoveSignal(%8lx)\n", Signal);*/
  2342.  
  2343.     WaitSignals &= ~Signal;
  2344.  
  2345.     for( k = 0; k < MAXSIGNALS; k++ )
  2346.     {
  2347.         if( Signals[ k ] == Signal )
  2348.         {
  2349.             SignalFunktionTab[ k ] = 0;
  2350.             Signals[ k ] = 0;
  2351.             if( !Found )
  2352.                 Found = TRUE;
  2353. /*            else*/
  2354. /*                kprintf("Warnung!: Signal doppelt belegt!\n");*/
  2355.         }
  2356.     }
  2357. }
  2358.  
  2359. #define MAXWDWINDOWS 10
  2360. static struct WindowData *OpenWD[ MAXWDWINDOWS ];
  2361. static int OpenWDCount;
  2362.  
  2363. void MyAddWindow( struct WindowData *wd )
  2364. {
  2365.     int k;
  2366.  
  2367.     mainflags |= MF_WDWINDOWOPEN;
  2368.  
  2369.     for( k = 0; k < MAXWDWINDOWS; k++ )
  2370.     {
  2371.         if( !OpenWD[ k ])
  2372.         {
  2373.             OpenWD[ k ] = wd;
  2374.             break;
  2375.         }
  2376.     }
  2377.  
  2378.     OpenWDCount++;
  2379. }
  2380.  
  2381. void MyRemoveWindow( struct WindowData *wd )
  2382. {
  2383.     int k;
  2384.  
  2385.     OpenWDCount--;
  2386.  
  2387.     if( !OpenWDCount )
  2388.         mainflags &= ~MF_WDWINDOWOPEN;
  2389.     
  2390.     for( k = 0; k < MAXWDWINDOWS; k++ )
  2391.     {
  2392.         if( OpenWD[ k ] == wd)
  2393.         {
  2394.             OpenWD[ k ] = NULL;
  2395.             break;
  2396.         }
  2397.     }
  2398. }
  2399.  
  2400. void CloseAllOpenWindows( void )
  2401. {
  2402.     int k;
  2403.  
  2404.     for( k = 0; k < MAXWDWINDOWS; k++ )
  2405.     {
  2406.         if( OpenWD[ k ])
  2407.         {
  2408.             NewCloseAWindow( OpenWD[ k ]);
  2409.             OpenWD[ k ] = NULL;
  2410.         }
  2411.     }
  2412.  
  2413.     if( mainflags & MF_LISTREQ )
  2414.         CloseLR();
  2415. }
  2416.  
  2417. void __saveds DoWindow(void)
  2418. {
  2419.     ULONG signals;
  2420.  
  2421.         /* Stimmt die Checksumme nicht? */
  2422. /* Removed by Pavel Fedin
  2423.     if( 0 == ChecksumCorrect())
  2424.     {
  2425.         DisplayLocaleText( MSG_INFO_GLOBAL_PATCHED );
  2426.     }
  2427.     else
  2428.     {*/
  2429.             /* Display öffnen */
  2430.     
  2431.         if(OpenDisplay()) return;
  2432.     
  2433.             /* Ggf. ein Startarexxscript ausführen */
  2434.     
  2435. #ifdef AREXX
  2436.         if(startuparexxscript)
  2437.         {
  2438.             BPTR fh;
  2439.     
  2440.             if(fh=Open(arexxcommandwindow,MODE_NEWFILE))
  2441.                 SendRexxCommand(MyRexxHost,startuparexxscript,fh);
  2442.             FreeVec(startuparexxscript);
  2443.         }
  2444. #endif
  2445.  
  2446.         while( !( mainflags & MF_ENDE ))
  2447.         {
  2448.             long k;
  2449.  
  2450. /*            kprintf("Wait(%8lx)", WaitSignals );*/
  2451.  
  2452.             signals = Wait( WaitSignals );
  2453.  
  2454. /*            kprintf(" = %8lx\n", signals );*/
  2455.  
  2456.             for( k = 0; k < MAXSIGNALS; k++ )
  2457.             {
  2458.                 if( SignalFunktionTab[ k ] )
  2459.                     if( signals & Signals[ k ])
  2460.                         SignalFunktionTab[ k ]();
  2461.             }
  2462.     
  2463.             if( mainflags & MF_ICONIFY )
  2464.             {
  2465.                 mainflags &= ~MF_ICONIFY;
  2466.  
  2467.                 if( MakeIconify() == FALSE )
  2468.                     DisplayLocaleText( MSG_INFO_GLOBAL_ICONIFYFAILED );
  2469.             }
  2470.         }
  2471.  
  2472.         if( mainflags & MF_CALC )
  2473.             CloseCalc();
  2474.         if( mainflags & MF_CLIPCONV )
  2475.             CloseClipConv();
  2476.  
  2477.         CloseCommandShell();
  2478.         CloseAllOpenWindows();
  2479. //    }
  2480. }
  2481.  
  2482. UBYTE *AllocRequester()
  2483. { 
  2484.         /* Den Haupt-Filerequester allokieren */
  2485.  
  2486.     if( UseAsl )
  2487.     {
  2488.         if(!(Asl_FileFileReq=(struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  2489.                                         ASL_FuncFlags,FILF_PATGAD|FILF_NEWIDCMP,
  2490.                                         TAG_DONE)))
  2491.             return(GetStr(MSG_INFO_GLOBAL_CANTALLOCFILEREQ));
  2492.     }
  2493.     else
  2494.     {
  2495.         if( !( FileFileReq = rtAllocRequestA( RT_FILEREQ, NULL )))
  2496.             return( GetStr( MSG_INFO_GLOBAL_CANTALLOCFILEREQ ));
  2497.     }
  2498.  
  2499.     return(0);
  2500. }
  2501.  
  2502. void FreeRequester(void)
  2503. {
  2504.     if( UseAsl )
  2505.     {
  2506.         if( Asl_FileFileReq ) FreeAslRequest( Asl_FileFileReq );
  2507.     }
  2508.     else
  2509.     {
  2510.         if( FileFileReq ) rtFreeRequest( FileFileReq );
  2511.     }
  2512. }
  2513.  
  2514. void LocalizeAll( void )
  2515. {
  2516.     LocalizeMenus();
  2517. }
  2518.  
  2519. static UBYTE *MyOpenLibrary(char *name, ULONG version, APTR *baseptr)
  2520. {
  2521.     if(!(*baseptr = OpenLibrary(name, version)))
  2522.     {
  2523.         sprintf(errorbuffer,GetStr(MSG_INFO_GLOBAL_CANTOPENLIBRARY), name, version);
  2524.         return(errorbuffer);
  2525.     }
  2526.     else
  2527.         return(0);
  2528. }
  2529.  
  2530. UBYTE *OpenLibs(void)
  2531. {
  2532.     char *errortext;
  2533.  
  2534.     LocaleBase = (struct LocaleBase *)OpenLibrary("locale.library", 38);
  2535.     if(errortext = MyOpenLibrary("dos.library", 37, (APTR *)&DOSBase)) return(errortext);
  2536.     if(errortext = MyOpenLibrary("intuition.library", 37, (APTR *)&IntuitionBase)) return(errortext);
  2537.     if(errortext = MyOpenLibrary("graphics.library", 37, (APTR *)&GfxBase)) return(errortext);
  2538.     if(errortext = MyOpenLibrary("icon.library", 37, (APTR *)&IconBase)) return(errortext);
  2539.     if(errortext = MyOpenLibrary("commodities.library", 37, (APTR *)&CxBase)) return(errortext);
  2540.     if(errortext = MyOpenLibrary("asl.library", 37, (APTR *)&AslBase)) return(errortext);
  2541.     if(errortext = MyOpenLibrary("rexxsyslib.library", 36, (APTR *)&RexxSysBase)) return(errortext);
  2542.     if(errortext = MyOpenLibrary("utility.library", 37, (APTR *)&UtilityBase)) return(errortext);
  2543.     if(errortext = MyOpenLibrary("gadtools.library", 37, (APTR *)&GadToolsBase)) return(errortext);
  2544.     if(errortext = MyOpenLibrary("diskfont.library", 35, (APTR *)&DiskfontBase)) return(errortext);
  2545.     if(errortext = MyOpenLibrary("workbench.library", 37, (APTR *)&WorkbenchBase)) return(errortext);
  2546.     if(errortext = MyOpenLibrary("iffparse.library", 37, (APTR *)&IFFParseBase)) return(errortext);
  2547.     if(errortext = MyOpenLibrary("keymap.library", 37, (APTR *)&KeymapBase)) return(errortext);
  2548.  
  2549.     ReqToolsBase = ( struct ReqToolsBase * )OpenLibrary( REQTOOLSNAME, 38);
  2550.  
  2551.     if( ReqToolsBase ) UseAsl = FALSE;
  2552.  
  2553. /*    XpkBase=OpenLibrary(XPKNAME,0);*/
  2554.  
  2555.     return(0);
  2556. }
  2557.  
  2558. void CloseAll(void)
  2559. {
  2560.     long k;
  2561.  
  2562.         /* Display schließen */
  2563.  
  2564.     while(FALSE==CloseDisplay());
  2565.  
  2566.     if( SollPublicScreenName )
  2567.         FreeVec( SollPublicScreenName );
  2568.  
  2569.     if( TextLineBuffer ) FreeVec( TextLineBuffer );
  2570.     FreeTempBitMap();
  2571.  
  2572.     FreeRequester();
  2573.  
  2574.     while( !IsListEmpty( &OldFileList ))
  2575.         FreeNLNode( OldFileList.lh_Head );
  2576.  
  2577.     while( !IsListEmpty( &DisplayInhaltList ))
  2578.         FreeDI(( struct DisplayInhalt * )DisplayInhaltList.lh_Head );
  2579.  
  2580.     while( !IsListEmpty( &FileList ))
  2581.         FreeFD(( struct FileData * )FileList.lh_Head );
  2582.  
  2583.         /* Alle ARexxcommands freigeben */
  2584.  
  2585.     for(k=0;k<10;k++)
  2586.         if(arexxcommands[k])FreeVec(arexxcommands[k]);
  2587.  
  2588.         /* Windowstrings freigeben */
  2589.  
  2590.     if(arexxcommandshellwindow)FreeVec(arexxcommandshellwindow);
  2591.     if(arexxcommandwindow)FreeVec(arexxcommandwindow);
  2592.  
  2593. #ifdef AREXX
  2594.     if(MyRexxHost)CloseDownARexxHost(MyRexxHost);
  2595. #endif
  2596.     FreeSearchHistory();
  2597.  
  2598.         /* Windowport freigeben */
  2599.  
  2600.     MyRemoveSignal( 1L << WndPort->mp_SigBit );
  2601.     DeleteMsgPort( WndPort );
  2602.  
  2603.         /* Appport freigeben */
  2604.  
  2605.     MyRemoveSignal( 1L << AppPort->mp_SigBit );
  2606.     DeleteMsgPort( AppPort );
  2607.  
  2608.         /* ReplyPort freigeben */
  2609.  
  2610.     FreeReplyPort();
  2611.  
  2612.     SetTaskPri( FindTask( NULL ), oldtaskpri );
  2613.  
  2614.     if( LocaleBase )
  2615.     {
  2616.         CloseCatalog(Catalog);
  2617.         CloseLocale(Locale);
  2618.     }
  2619. }
  2620.  
  2621. void CloseLibs(void)
  2622. {
  2623. /*    if(XpkBase) CloseLibrary(XpkBase);*/
  2624.  
  2625.     CloseLibrary((struct Library *)ReqToolsBase);
  2626.  
  2627.     CloseLibrary(CxBase);
  2628.     CloseLibrary(KeymapBase);
  2629.     CloseLibrary(UtilityBase);
  2630.     CloseLibrary((struct Library *)IntuitionBase);
  2631.     CloseLibrary((struct Library *)GfxBase);
  2632.     CloseLibrary(GadToolsBase);
  2633.     CloseLibrary(DiskfontBase);
  2634.     CloseLibrary(AslBase);
  2635.     CloseLibrary(RexxSysBase);
  2636.     CloseLibrary((struct Library *)IconBase);
  2637.     CloseLibrary(WorkbenchBase);
  2638.     CloseLibrary(IFFParseBase);
  2639.     CloseLibrary((struct Library *)DOSBase);
  2640.  
  2641.     CloseLibrary((struct Library *)LocaleBase);
  2642. }
  2643. /* Removed registration stuff - Pavel Fedin
  2644. #define GHOEHE 16
  2645. #define GBREITE 62
  2646.  
  2647. void Gedenken( void )
  2648. {
  2649.     struct Window *Wnd;
  2650.     struct TextAttr ta;
  2651.     struct TextFont *tf;
  2652.     APTR VisualInfo;
  2653.     struct Screen *Scr;
  2654.     int k;
  2655.  
  2656.     Scr = LockPubScreen( NULL );
  2657.  
  2658.     ta.ta_Name = GfxBase->DefaultFont->tf_Message.mn_Node.ln_Name;
  2659.     ta.ta_YSize = GfxBase->DefaultFont->tf_YSize;
  2660.     ta.ta_Style = 0;
  2661.     ta.ta_Flags = 0;
  2662.  
  2663.     if( !( tf = OpenDiskFont( &ta )))
  2664.     {
  2665.         ta.ta_Name = "topaz.font";
  2666.         ta.ta_YSize = 8;
  2667.         tf = OpenDiskFont( &ta );
  2668.     }
  2669.  
  2670.     Wnd = OpenWindowTags( NULL,
  2671.                 WA_Left,    (Scr->Width - GBREITE * tf->tf_XSize - 8)/2,
  2672.                 WA_Top,    (Scr->Height - GHOEHE * tf->tf_YSize - 4)/2,
  2673. //                WA_Title,    "FileX 2.0 Nerv Requester",
  2674.                 WA_InnerWidth,    GBREITE * tf->tf_XSize + 8,
  2675.                 WA_InnerHeight,GHOEHE * tf->tf_YSize + 4,
  2676.                 WA_Flags,        WFLG_RMBTRAP | WFLG_BORDERLESS | WFLG_SMART_REFRESH | WFLG_ACTIVATE,
  2677.                 WA_PubScreen,    Scr,
  2678.                 TAG_DONE );
  2679.  
  2680.     if( Wnd && tf )
  2681.     {
  2682.         SetRast( Wnd->RPort, 3 );
  2683.  
  2684.         if( VisualInfo = GetVisualInfo( Wnd->WScreen, TAG_DONE ))
  2685.         {
  2686.             DrawBevelBox( Wnd->RPort, Wnd->BorderLeft, Wnd->BorderTop, Wnd->Width - Wnd->BorderRight - Wnd->BorderLeft, Wnd->Height - Wnd->BorderTop - Wnd->BorderBottom, GT_VisualInfo, VisualInfo, TAG_DONE);
  2687.             FreeVisualInfo( VisualInfo );
  2688.         }
  2689.  
  2690.         if( tf )
  2691.             SetFont( Wnd->RPort, tf );
  2692.  
  2693.         SetAPen( Wnd->RPort, 1 );
  2694.         SetBPen( Wnd->RPort, 3 );
  2695.  
  2696.         for( k = 0; k < 14; k++ )
  2697.         {
  2698.             Move( Wnd->RPort, Wnd->BorderLeft + 4, Wnd->BorderTop + tf->tf_Baseline + tf->tf_YSize * (k+1) + 2);
  2699.             Text( Wnd->RPort, GetStr(MSG_INFO_GLOBAL_NERVREQUESTER) + k * GBREITE, GBREITE );
  2700.         }
  2701.  
  2702.         Delay( 200 );
  2703.  
  2704.             // Entweder 16 Sekunden oder 2 min warten :-)
  2705.  
  2706.         for( k = 0; k < 40; k++)
  2707.         {
  2708.             ActivateWindow( Wnd );
  2709.             WindowToFront( Wnd );
  2710.             ScreenToFront( Wnd->WScreen );
  2711.             Delay( 20 );
  2712.         }
  2713.     }
  2714.     else
  2715.     {
  2716.         Delay( 400 );
  2717.     }
  2718.  
  2719.     if( Scr ) UnlockPubScreen( NULL, Scr );
  2720.     if( Wnd ) CloseWindow( Wnd );
  2721.     if( tf ) CloseFont( tf );
  2722. }*/
  2723.